computer-use-ootb-internal 0.0.162__tar.gz → 0.0.164__tar.gz

{computer_use_ootb_internal-0.0.162 → computer_use_ootb_internal-0.0.164}/PKG-INFO

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

{computer_use_ootb_internal-0.0.162 → computer_use_ootb_internal-0.0.164}/pyproject.toml

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

{computer_use_ootb_internal-0.0.162 → computer_use_ootb_internal-0.0.164}/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"
@@ -226,7 +227,9 @@ class GuardService(win32serviceutil.ServiceFramework):
              self.log_info(f"Using target executable: {self.target_executable_path}")
 
         _service_instance = self
-        self.log_info(f"Service initialized. Target executable: {self.target_executable_path}.")
+        # Determine path to the signal script
+        self.signal_script_path = self._find_signal_script()
+        self.log_info(f"Service initialized. Target executable: {self.target_executable_path}. Signal script: {self.signal_script_path}")
 
     def SvcStop(self):
         self.log_info(f"Service stop requested.")
@@ -706,19 +709,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, calculated_port)
-                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)
@@ -739,7 +732,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
@@ -756,61 +749,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. Create/Update and Trigger Scheduled Task
-            immediate_start_status = "start_attempted_task_trigger"
-            self.log_info(f"Internal trigger: User '{user}' is active and not running. Attempting start via Task Scheduler...")
+            # 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
 
-            # --- Start Task Scheduler logic --- 
             try:
-                # Step 4a: Ensure the task is created/updated correctly
-                # Pass calculated port to the task creation function
-                task_created = self.create_or_update_logon_task(user, calculated_port)
-                if not task_created:
-                    self.log_error(f"Internal trigger: Failed to create/update scheduled task for user '{user}'. Cannot proceed with start.")
-                    final_status = "failed_task_creation"
+                # 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
-                
-                # Step 4b: Trigger the task to run immediately
-                task_name = f"OOTB_UserConnect_{user}" # Must match the name used in create_or_update_logon_task
-                trigger_command = ["schtasks", "/Run", "/TN", task_name]
-                self.log_info(f"Internal trigger: Attempting to run task '{task_name}' immediately using: {trigger_command}")
-
-                result = subprocess.run(
-                    trigger_command,
-                    capture_output=True,
-                    text=True,
-                    check=False, # Check return code manually
-                    encoding='utf-8',
-                    errors='ignore' 
+
+                # 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}'
                 )
 
-                if result.stdout:
-                    self.log_info(f"Internal trigger: schtasks /Run STDOUT:\n{result.stdout.strip()}")
-                if result.stderr:
-                    # schtasks often prints success message to stderr, log as info
-                    self.log_info(f"Internal trigger: schtasks /Run STDERR:\n{result.stderr.strip()}") 
-                
-                if result.returncode == 0 or "SUCCESS: Attempted to run the scheduled task" in result.stdout or "SUCCESS: Attempted to run the scheduled task" in result.stderr:
-                    self.log_info(f"Internal trigger: Successfully triggered task '{task_name}' for user '{user}'.")
-                    immediate_start_status = "start_success_task_triggered"
-                    final_status = "success_task_triggered"
-                else:
-                    self.log_error(f"Internal trigger: Failed to trigger task '{task_name}' (Exit Code: {result.returncode}).")
-                    immediate_start_status = f"start_failed_task_trigger_code_{result.returncode}"
-                    final_status = f"failed_task_trigger_code_{result.returncode}"
-
-            except FileNotFoundError:
-                self.log_error("Internal trigger: 'schtasks.exe' not found.")
-                immediate_start_status = "start_failed_schtasks_not_found"
-                final_status = "failed_schtasks_not_found"
-            except Exception as task_trigger_err:
-                self.log_error(f"Internal trigger: Exception during task trigger for user '{user}': {task_trigger_err}", exc_info=True)
-                immediate_start_status = "start_failed_task_trigger_exception"
-                final_status = "failed_task_trigger_exception"
-            # --- End Task Scheduler logic ---
+                # 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}")
+
+                # 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.")
+                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"
+            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)
-            # 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:
@@ -818,35 +850,48 @@ class GuardService(win32serviceutil.ServiceFramework):
              return "failed_trigger_exception"
 
 
-    def create_or_update_logon_task(self, username, port):
+    def create_or_update_logon_task(self, username):
         """Creates/updates task to trigger the internal signal script on session connect."""
-        if not self.target_executable_path:
-            self.log_error(f"Cannot create task for {username}: Target executable path not found.")
+        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}"
-        target_exe_unquoted = self.target_executable_path.strip('"')
-        target_exe_for_ps = target_exe_unquoted.replace("'", "''")
-        action_arguments = f"--port {port} --target_user '{username}'".replace("'", "''") # Arguments for the target exe
-
-        # Working directory for the executable
+        # 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:
-            target_dir = os.path.dirname(target_exe_unquoted)
-            if not target_dir: target_dir = "."
-            safe_working_directory = target_dir.replace("'", "''")
+            script_dir = os.path.dirname(self.signal_script_path.strip('"'))
+            if not script_dir: script_dir = "."
+            safe_working_directory = script_dir.replace("'", "''")
             working_directory_setting = f"$action.WorkingDirectory = '{safe_working_directory}'"
         except Exception as e:
-             self.log_error(f"Error determining working directory for target exe task: {e}. WD will not be set.")
+             self.log_error(f"Error determining working directory for signal script task: {e}. WD will not be set.")
              working_directory_setting = "# Could not set WorkingDirectory"
 
         # PowerShell command construction
         ps_command = f"""
         $taskName = "{task_name}"
-        # Principal runs as the user, but with highest privileges
-        $principal = New-ScheduledTaskPrincipal -UserId "{username}" -LogonType Interactive -RunLevel Highest
+        $principal = New-ScheduledTaskPrincipal -UserId "{username}" -LogonType Interactive
         
-        # Action: Run the target executable directly with arguments
-        $action = New-ScheduledTaskAction -Execute '{target_exe_for_ps}' -Argument '{action_arguments}'
+        # 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)
@@ -916,6 +961,49 @@ class GuardService(win32serviceutil.ServiceFramework):
         self.log_info(f"Attempted removal of scheduled task '{task_name}' for user '{username}'.")
         return True
 
+    def _find_signal_script(self):
+        """Finds the signal_connection.py script relative to this service file."""
+        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)
+            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
+                return script_path
+            else:
+                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 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 ---
 if __name__ == '__main__':
     if len(sys.argv) > 1 and sys.argv[1] == 'debug':

computer_use_ootb_internal-0.0.164/src/computer_use_ootb_internal/launch_ootb_elevated.ps1

@@ -0,0 +1,69 @@
+# 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 second argument for cmd.exe /K, precisely matching the working command
+    # Format: "<quoted_exe_path>" --port <port> --target_user ''<username>''
+    # Note: PowerShell handles escaping within double quotes differently.
+    #       Using backticks ` before inner quotes is safer here.
+    $cmdKSecondArg = "`"`"$TargetExePath`"`" --port $Port --target_user ''$TargetUser''"
+
+    # Construct the argument list array for Start-Process launching cmd.exe
+    $startProcessArgs = @('/K', $cmdKSecondArg)
+
+    Write-Host "Constructed cmd.exe /K arguments: $cmdKSecondArg"
+    Write-Host "Constructed Start-Process arguments array: $($startProcessArgs -join ' ')" # For logging
+    Write-Host "Executing elevated process..."
+    Write-Host "Command: Start-Process -FilePath cmd.exe -ArgumentList @('/K', '$cmdKSecondArg') -WorkingDirectory '$WorkingDirectory' -Verb RunAs"
+    Write-Host "--- Waiting for UAC prompt if necessary ---"
+
+    # Execute the command to launch cmd elevated, which runs the target app
+    Start-Process -FilePath cmd.exe -ArgumentList $startProcessArgs -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