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

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

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

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

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

{computer_use_ootb_internal-0.0.161 → computer_use_ootb_internal-0.0.162}/src/computer_use_ootb_internal/guard_service.py

@@ -226,9 +226,7 @@ class GuardService(win32serviceutil.ServiceFramework):
              self.log_info(f"Using target executable: {self.target_executable_path}")
 
         _service_instance = self
-        # 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}")
+        self.log_info(f"Service initialized. Target executable: {self.target_executable_path}.")
 
     def SvcStop(self):
         self.log_info(f"Service stop requested.")
@@ -710,7 +708,7 @@ 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 = 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)
@@ -758,78 +756,58 @@ class GuardService(win32serviceutil.ServiceFramework):
                  self.log_error(f"Internal trigger: Error checking existing processes for {user}: {e}")
                  # Continue and attempt start despite error?
 
-            # --- Removed CreateProcessAsUser logic ---
-            # 4. Attempt immediate start directly via subprocess calling PowerShell
-            immediate_start_status = "start_attempted_direct_subprocess"
-            self.log_info(f"Internal trigger: User '{user}' is active and not running. Attempting immediate start via direct PowerShell subprocess...")
-
-            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. 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...")
 
+            # --- Start Task Scheduler logic --- 
             try:
-                # Prepare paths and arguments, escaping for PowerShell strings
-                target_exe_unquoted = self.target_executable_path.strip('"')
-                target_exe_for_ps = target_exe_unquoted.replace("'", "''")
-                target_exe_dir_for_ps = os.path.dirname(target_exe_unquoted).replace("'", "''")
-
-                # Build the exact Start-Process command string based on the working template as a single line
-                # Need to escape quotes carefully for the final -Command '...' argument
-                # 1. Build the second argument for the @() array element
-                cmd_k_second_arg = f'"\\"{target_exe_for_ps}\\"" --port {calculated_port} --target_user \'\'{user}\'\''
-                # 2. Escape single quotes within it for the PS literal array element
-                cmd_k_second_arg_escaped_for_array = cmd_k_second_arg.replace("'", "''")
-                # 3. Build the full script block content as a single line string
-                ps_script_block_content = f"$cmdArgs = @('/K', '{cmd_k_second_arg_escaped_for_array}'); Start-Process -FilePath cmd.exe -ArgumentList $cmdArgs -WorkingDirectory '{target_exe_dir_for_ps}' -Verb RunAs"
-                # 4. Escape single quotes in the whole script block for the outer -Command '...'
-                ps_script_block_content_escaped = ps_script_block_content.replace("'", "''")
-
-                # Command list for subprocess
-                powershell_executable = "powershell.exe"
-                command_list = [
-                    powershell_executable,
-                    "-NoProfile",
-                    "-ExecutionPolicy", "Bypass",
-                    "-Command",
-                    f"{{ {ps_script_block_content_escaped} }}" # Use script block {}
-                ]
-
-                self.log_info(f"Internal trigger: Executing subprocess: {command_list}")
-
-                # Execute the command directly from the service context
+                # 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"
+                    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(
-                    command_list,
+                    trigger_command,
                     capture_output=True,
                     text=True,
-                    check=False, # Don't raise exception on non-zero exit
+                    check=False, # Check return code manually
                     encoding='utf-8',
-                    errors='ignore'
+                    errors='ignore' 
                 )
 
-                # Log results
                 if result.stdout:
-                    self.log_info(f"Internal trigger: PowerShell STDOUT:\\n{result.stdout.strip()}")
+                    self.log_info(f"Internal trigger: schtasks /Run STDOUT:\n{result.stdout.strip()}")
                 if result.stderr:
-                    self.log_warning(f"Internal trigger: PowerShell STDERR:\\n{result.stderr.strip()}")
-
-                if result.returncode == 0:
-                    self.log_info("Internal trigger: PowerShell subprocess command executed successfully (Exit Code 0). Process likely started elevated in background.")
-                    immediate_start_status = "start_success_direct_subprocess"
-                    final_status = "success_direct_subprocess"
+                    # 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: PowerShell subprocess command failed (Exit Code {result.returncode}).")
-                    immediate_start_status = f"start_failed_direct_subprocess_code_{result.returncode}"
-                    final_status = f"failed_direct_subprocess_code_{result.returncode}"
+                    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: 'powershell.exe' not found.")
-                immediate_start_status = "start_failed_ps_not_found"
-                final_status = "failed_ps_not_found"
-            except Exception as subproc_err:
-                self.log_error(f"Internal trigger: Exception during PowerShell subprocess execution for user '{user}': {subproc_err}", exc_info=True)
-                immediate_start_status = "start_failed_subprocess_exception"
-                final_status = "failed_subprocess_exception"
+                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 ---
 
             # Combine results (mostly determined by start attempt now)
             # Example: final_status = f"{task_created_status}_{immediate_start_status}"
@@ -840,48 +818,35 @@ class GuardService(win32serviceutil.ServiceFramework):
              return "failed_trigger_exception"
 
 
-    def create_or_update_logon_task(self, username):
+    def create_or_update_logon_task(self, username, port):
         """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.")
+        if not self.target_executable_path:
+            self.log_error(f"Cannot create task for {username}: Target executable path not found.")
             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)
+        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
         try:
-            script_dir = os.path.dirname(self.signal_script_path.strip('"'))
-            if not script_dir: script_dir = "."
-            safe_working_directory = script_dir.replace("'", "''")
+            target_dir = os.path.dirname(target_exe_unquoted)
+            if not target_dir: target_dir = "."
+            safe_working_directory = target_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.")
+             self.log_error(f"Error determining working directory for target exe 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
+        # Principal runs as the user, but with highest privileges
+        $principal = New-ScheduledTaskPrincipal -UserId "{username}" -LogonType Interactive -RunLevel Highest
         
-        # Action: Run python signal script
-        $action = New-ScheduledTaskAction -Execute '{safe_action_executable}' -Argument '{safe_action_arguments}'
+        # Action: Run the target executable directly with arguments
+        $action = New-ScheduledTaskAction -Execute '{target_exe_for_ps}' -Argument '{action_arguments}'
         {working_directory_setting}
 
         # Trigger: On session connect (Event ID 21)
@@ -951,24 +916,6 @@ class GuardService(win32serviceutil.ServiceFramework):
         self.log_info(f"Attempted removal of scheduled task '{task_name}' for user '{username}'.")
         return True
 
-    def _find_signal_script(self):
-        """Finds the signal_connection.py script relative to this service file."""
-        try:
-            base_dir = os.path.dirname(os.path.abspath(__file__))
-            script_path = os.path.join(base_dir, "signal_connection.py")
-            if os.path.exists(script_path):
-                self.log_info(f"Found signal script at: {script_path}")
-                # Quote if needed?
-                if " " in script_path and not script_path.startswith('"'):
-                    return f'"{script_path}"'
-                return script_path
-            else:
-                self.log_error(f"Signal script signal_connection.py not found near {base_dir}")
-                return None
-        except Exception as e:
-            self.log_error(f"Error finding signal script: {e}")
-            return None
-
 # --- Main Execution Block ---
 if __name__ == '__main__':
     if len(sys.argv) > 1 and sys.argv[1] == 'debug':