computer-use-ootb-internal 0.0.127__tar.gz → 0.0.128__tar.gz

{computer_use_ootb_internal-0.0.127 → computer_use_ootb_internal-0.0.128}/PKG-INFO

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

{computer_use_ootb_internal-0.0.127 → computer_use_ootb_internal-0.0.128}/pyproject.toml

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

{computer_use_ootb_internal-0.0.127 → computer_use_ootb_internal-0.0.128}/src/computer_use_ootb_internal/guard_service.py

@@ -104,6 +104,8 @@ def receive_command():
 
 # --- End PowerShell Task Scheduler Helpers ---
 
+TARGET_EXECUTABLE_NAME = "computer-use-ootb-internal.exe"
+
 class GuardService(win32serviceutil.ServiceFramework):
     _svc_name_ = _SERVICE_NAME
     _svc_display_name_ = _SERVICE_DISPLAY_NAME
@@ -134,145 +136,43 @@ class GuardService(win32serviceutil.ServiceFramework):
     # --- End Instance Logging --- 
 
     # --- Instance Helper Methods (Moved from module level) ---
-    def get_base_python_executable(self):
-        """Tries to find pythonw.exe or python.exe instead of pythonservice.exe if running as service."""
-        service_exe = sys.executable
-        self.log_info(f"get_base_python_executable: sys.executable is {service_exe}")
-        service_exe_lower = service_exe.lower()
-        final_exe_to_use = service_exe # Default to sys.executable
-
-        if 'pythonservice.exe' in os.path.basename(service_exe_lower):
-            dir_name = os.path.dirname(service_exe)
-            potential_pythonw_exe = os.path.join(dir_name, 'pythonw.exe')
-            potential_python_exe = os.path.join(dir_name, 'python.exe')
-            
-            self.log_info(f"get_base_python_executable: Checking for pythonw.exe at {potential_pythonw_exe}")
-            if os.path.exists(potential_pythonw_exe):
-                self.log_info(f"get_base_python_executable: Found pythonw.exe, preferring it.")
-                final_exe_to_use = potential_pythonw_exe
-            else:
-                self.log_info(f"get_base_python_executable: pythonw.exe not found. Checking for python.exe at {potential_python_exe}")
-                if os.path.exists(potential_python_exe):
-                     self.log_info(f"get_base_python_executable: Found python.exe.")
-                     final_exe_to_use = potential_python_exe
-                else:
-                    self.log_error(f"get_base_python_executable: Could not find pythonw.exe or python.exe near pythonservice.exe. Falling back to using {service_exe}.")
-                    # Keep final_exe_to_use as service_exe (default)
-        else:
-            self.log_info(f"get_base_python_executable: sys.executable is not pythonservice.exe, using it directly.")
-            # Keep final_exe_to_use as service_exe (default)
-
-        # Quote the final selected path if necessary
-        if " " in final_exe_to_use and not final_exe_to_use.startswith('"'):
-            return f'"{final_exe_to_use}"'
-        return final_exe_to_use
-
-    def get_python_executable(self):
-        # This method is now just an alias for clarity if needed elsewhere,
-        # but primary logic uses get_base_python_executable directly.
-        # Keep for potential compatibility if anything still calls it.
-        return self.get_base_python_executable()
-
-    def get_pip_executable(self):
-        """Tries to locate the pip executable in the same environment."""
+    def _find_target_executable(self):
+        """Finds the target executable (e.g., computer-use-ootb-internal.exe) in the Scripts directory."""
         try:
-            # Use the potentially corrected python path to find pip's location
-            # Note: This assumes pip is relative to python.exe, not pythonservice.exe
-            base_python = self.get_base_python_executable()
-            python_path = pathlib.Path(base_python.strip('"')) # Use unquoted path
-            pip_path = python_path.parent / "Scripts" / "pip.exe"
-            self.log_info(f"get_pip_executable: Checking for pip relative to {python_path.parent} at {pip_path}")
-
-            if pip_path.exists():
-                self.log_info(f"get_pip_executable: pip.exe found at {pip_path}")
-                pip_exe = str(pip_path)
-                if " " in pip_exe and not pip_exe.startswith('"'):
-                    pip_exe = f'"{pip_exe}"'
-                return pip_exe
+            # sys.executable should be python.exe or pythonservice.exe in the env root/Scripts
+            env_dir = os.path.dirname(sys.executable)
+            # If sys.executable is in Scripts, go up one level
+            if os.path.basename(env_dir.lower()) == 'scripts':
+                env_dir = os.path.dirname(env_dir)
+
+            scripts_dir = os.path.join(env_dir, 'Scripts')
+            target_exe_path = os.path.join(scripts_dir, TARGET_EXECUTABLE_NAME)
+
+            self.log_info(f"_find_target_executable: Checking for executable at: {target_exe_path}")
+
+            if os.path.exists(target_exe_path):
+                self.log_info(f"_find_target_executable: Found executable: {target_exe_path}")
+                # Quote if necessary for command line usage
+                if " " in target_exe_path and not target_exe_path.startswith('"'):
+                    return f'"{target_exe_path}"'
+                return target_exe_path
             else:
-                self.log_error(f"get_pip_executable: pip.exe NOT found at {pip_path}. Falling back to '{base_python} -m pip'.")
-                pass
-        except Exception as e:
-            self.log_error(f"get_pip_executable: Error determining pip path: {e}", exc_info=True)
-            self.log_error(f"get_pip_executable: Falling back to 'python -m pip' due to error.")
-        
-        # Fallback uses the potentially corrected python path
-        return f"{self.get_base_python_executable()} -m pip"
-
-    # --- PowerShell Methods (Moved from module level) ---
-    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:
-                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:
-            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 create_or_update_logon_task(self, username, task_command, python_executable):
-        """Creates or updates a scheduled task to run a command at user logon."""
-        task_name = f"{self._task_name_prefix}{username}"
-        safe_python_exe = python_executable.replace("'", "''")
-        command_parts = task_command.split(' ', 1)
-        if len(command_parts) > 1 and command_parts[0] == python_executable:
-             safe_task_command_args = command_parts[1].replace("'", "''")
-        else:
-             safe_task_command_args = task_command.replace(python_executable, "").strip().replace("'", "''")
-
-        safe_task_name = task_name.replace("'", "''")
-        safe_username = username.replace("'", "''")
-
-        action = f"$Action = New-ScheduledTaskAction -Execute '{safe_python_exe}' -Argument '{safe_task_command_args}'"
-        trigger = f"$Trigger = New-ScheduledTaskTrigger -AtLogOn -User '{safe_username}'"
-        principal = f"$Principal = New-ScheduledTaskPrincipal -UserId '{safe_username}' -LogonType Interactive"
-        settings = "$Settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -DontStopOnIdleEnd -ExecutionTimeLimit ([System.TimeSpan]::Zero) -RunOnlyIfNetworkAvailable:$false"
-
-        command = f"""
-        try {{
-            {action}
-            {trigger}
-            {principal}
-            {settings}
-            Register-ScheduledTask -TaskName '{safe_task_name}' -Action $Action -Trigger $Trigger -Principal $Principal -Settings $Settings -Force -ErrorAction Stop
-            Write-Host "Scheduled task '{safe_task_name}' registered/updated successfully."
-        }} catch {{
-            Write-Error "Failed to register/update scheduled task '{safe_task_name}': $_"
-            exit 1
-        }}
-        """
-        success = self.run_powershell_command(command)
-        if success:
-            self.log_info(f"Successfully created/updated scheduled task '{task_name}' for user '{username}'.")
-        else:
-            self.log_error(f"Failed to create/update scheduled task '{task_name}' for user '{username}'.")
-        return success
+                self.log_error(f"_find_target_executable: Target executable not found at {target_exe_path}")
+                # Fallback: Check env root directly (less common for scripts)
+                target_exe_path_root = os.path.join(env_dir, TARGET_EXECUTABLE_NAME)
+                self.log_info(f"_find_target_executable: Checking fallback location: {target_exe_path_root}")
+                if os.path.exists(target_exe_path_root):
+                     self.log_info(f"_find_target_executable: Found executable at fallback location: {target_exe_path_root}")
+                     if " " in target_exe_path_root and not target_exe_path_root.startswith('"'):
+                         return f'"{target_exe_path_root}"'
+                     return target_exe_path_root
+                else:
+                     self.log_error(f"_find_target_executable: Target executable also not found at {target_exe_path_root}")
+                     return None
 
-    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
-    # --- End Instance Helper Methods ---
+        except Exception as e:
+            self.log_error(f"Error finding target executable: {e}")
+            return None
 
     def __init__(self, args):
         global _service_instance
@@ -284,13 +184,16 @@ class GuardService(win32serviceutil.ServiceFramework):
         self.command_processor_thread = None
         self.session = requests.Session()
 
-        # Initialize paths using instance methods that prefer python.exe
-        self.python_exe = self.get_base_python_executable()
-        self.pip_command_base = self.get_pip_executable()
-        # Construct command using the potentially corrected python.exe path
-        self.ootb_command = f"{self.python_exe} -m {_OOTB_MODULE}"
+        self.target_executable_path = self._find_target_executable()
+        if not self.target_executable_path:
+             # Log error and potentially stop service if critical executable is missing
+             self.log_error(f"CRITICAL: Could not find {TARGET_EXECUTABLE_NAME}. Service cannot function.")
+             # Consider stopping the service here if needed, or handle appropriately
+        else:
+             self.log_info(f"Using target executable: {self.target_executable_path}")
+
         _service_instance = self
-        self.log_info(f"Service initialized. OOTB command set to: {self.ootb_command}")
+        self.log_info(f"Service initialized. Target executable set to: {self.target_executable_path}")
 
     def SvcStop(self):
         self.log_info(f"Service stop requested.")
@@ -418,11 +321,11 @@ class GuardService(win32serviceutil.ServiceFramework):
 
     def handle_update(self):
         self.log_info("Executing OOTB update...")
-        if not self.pip_command_base:
-            self.log_error("Cannot update: pip command not found.")
-            return "failed_pip_not_found"
+        if not self.target_executable_path:
+            self.log_error("Cannot update: Target executable not found.")
+            return "failed_executable_not_found"
 
-        update_command = f"{self.pip_command_base} install --upgrade --no-cache-dir {_PACKAGE_NAME}"
+        update_command = f"{self.target_executable_path} update"
         self.log_info(f"Running update command: {update_command}")
         try:
             result = subprocess.run(update_command, shell=True, capture_output=True, text=True, check=True, timeout=300, encoding='utf-8')
@@ -452,7 +355,7 @@ class GuardService(win32serviceutil.ServiceFramework):
             self.log_info(f"Searching for OOTB processes for users: {target_users}")
             
             # Use the potentially corrected python.exe path for matching
-            python_exe_path_for_check = self.python_exe.strip('"') 
+            python_exe_path_for_check = self.target_executable_path.strip('"') 
             self.log_info(f"_get_ootb_processes: Checking against python path: {python_exe_path_for_check}")
 
             for proc in psutil.process_iter(['pid', 'name', 'username', 'cmdline', 'exe']):
@@ -688,7 +591,7 @@ class GuardService(win32serviceutil.ServiceFramework):
 
                 # 1. Always try to create/update the scheduled task
                 try:
-                    task_created = self.create_or_update_logon_task(user, self.ootb_command, self.python_exe)
+                    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"Exception creating/updating scheduled task for {user}: {task_err}", exc_info=True)
@@ -719,7 +622,7 @@ class GuardService(win32serviceutil.ServiceFramework):
                             user_profile_dir = win32profile.GetUserProfileDirectory(token)
 
                             hProcess, hThread, dwPid, dwTid = win32process.CreateProcessAsUser(
-                                token, self.python_exe, self.ootb_command,
+                                token, self.target_executable_path,
                                 None, None, False, creation_flags, env, user_profile_dir, startup
                             )
                             self.log_info(f"CreateProcessAsUser call succeeded for user '{user}' (PID: {dwPid}). Checking existence...")
@@ -780,6 +683,57 @@ class GuardService(win32serviceutil.ServiceFramework):
              self.log_error(f"Error during combined start OOTB process: {e}", exc_info=True)
              return "failed_exception"
 
+    def create_or_update_logon_task(self, username):
+        """Creates or updates a scheduled task to run the OOTB app on user logon."""
+        if not self.target_executable_path:
+            self.log_error(f"Cannot create task for {username}: Target executable path is not set.")
+            return False
+
+        task_name = f"OOTB_UserLogon_{username}"
+        # Use the found target executable path directly
+        # No arguments needed if the executable handles everything
+        command_to_run = self.target_executable_path
+        # Arguments are now empty as the exe is called directly
+        arguments = ""
+
+        # Ensure command_to_run is properly quoted if it contains spaces
+        # The _find_target_executable should already handle quoting
+        # Example PowerShell command construction (adjust as needed)
+        ps_command = f"""
+        $taskName = "{task_name}"
+        $principal = New-ScheduledTaskPrincipal -UserId "{username}" -LogonType Interactive
+        # Action: Run the target executable directly
+        $action = New-ScheduledTaskAction -Execute '{command_to_run}'
+        # Optional: Set working directory if needed, otherwise it might default to System32 or user profile
+        # $action.WorkingDirectory = "C:\path\to\working\dir"
+        $trigger = New-ScheduledTaskTrigger -AtLogOn -User "{username}"
+        $settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -ExecutionTimeLimit (New-TimeSpan -Days 9999) -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1)
+        $description = "Runs OOTB Application for user {username} upon logon."
+
+        # 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 '{command_to_run}'")
+        try:
+            # ... (run PowerShell command) ...
+            self.log_info(f"Successfully ran PowerShell command to create/update task '{task_name}'.")
+            return True
+        except Exception as e:
+            self.log_error(f"Failed to create/update scheduled task '{task_name}' for user '{username}': {e}")
+            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
+
 # --- Main Execution Block ---
 if __name__ == '__main__':
     if len(sys.argv) > 1 and sys.argv[1] == 'debug':