computer-use-ootb-internal 0.0.120__tar.gz → 0.0.122__tar.gz

{computer_use_ootb_internal-0.0.120 → computer_use_ootb_internal-0.0.122}/PKG-INFO

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

computer_use_ootb_internal-0.0.122/deploy.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# Clean previous builds
+rm -rf dist
+
+# Build the package
+python -m build
+
+# Upload to PyPI using API key
+python -m twine upload dist/* -u __token__ -p pypi-AgEIcHlwaS5vcmcCJGNiMDY2MzY0LWU0YWItNGNkZi1iNmJiLWViOTVjYTQ1NDA3NgACKlszLCIyNjgwNjg2Yy1lZDk2LTQxZGYtYjE2MC02ZGRmYWM4YjBlMWQiXQAABiC8l1-r93zvUfQ4W-aqfGCKady5e-94jEFbPA1SFyDgCw

{computer_use_ootb_internal-0.0.120 → computer_use_ootb_internal-0.0.122}/pyproject.toml

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

{computer_use_ootb_internal-0.0.120 → computer_use_ootb_internal-0.0.122}/src/computer_use_ootb_internal/guard_service.py

@@ -87,150 +87,20 @@ def receive_command():
     return jsonify({"message": f"Command {command_id} received and queued"}), 202 # Accepted
 
 # --- Helper Functions --- Only logging helpers needed adjustments
-def get_python_executable():
-    python_exe = sys.executable
-    if " " in python_exe and not python_exe.startswith('"'):
-        python_exe = f'"{python_exe}"'
-    return python_exe
-
-def get_pip_executable():
-    """Tries to locate the pip executable in the same environment."""
-    try:
-        current_python = sys.executable
-        log_info(f"get_pip_executable: sys.executable = {current_python}")
-        python_path = pathlib.Path(current_python)
-        # Common location is ../Scripts/pip.exe relative to python.exe
-        pip_path = python_path.parent / "Scripts" / "pip.exe"
-        log_info(f"get_pip_executable: Checking for pip at {pip_path}")
-
-        if pip_path.exists():
-            log_info(f"get_pip_executable: pip.exe found at {pip_path}")
-            # Quote if necessary
-            pip_exe = str(pip_path)
-            if " " in pip_exe and not pip_exe.startswith('"'):
-                pip_exe = f'"{pip_exe}"'
-            return pip_exe
-        else:
-            log_error(f"get_pip_executable: pip.exe NOT found at {pip_path}. Falling back to 'python -m pip'.")
-            # Fallback is intended here
-            pass # Explicitly pass to reach the fallback return outside the else
-
-    except Exception as e:
-        log_error(f"get_pip_executable: Error determining pip path: {e}", exc_info=True)
-        log_error("get_pip_executable: Falling back to 'python -m pip' due to error.")
-    
-    # Fallback return statement if 'exists' is false or an exception occurred
-    return f"{get_python_executable()} -m pip"
-
-def log_info(msg):
-    thread_name = threading.current_thread().name
-    full_msg = f"[{thread_name}] {msg}"
-    logging.info(full_msg)
-    try:
-        # Only log to event log from main service thread or known non-daemon threads if possible
-        # Trying from waitress/flask threads might cause issues.
-        # For simplicity, maybe remove event log integration or make it conditional.
-        if threading.current_thread().name in ["MainThread", "CommandProcessor"]: # Example condition
-             servicemanager.LogInfoMsg(str(full_msg))
-    except Exception as e:
-        logging.warning(f"Could not write info to Windows Event Log: {e}")
-
-def log_error(msg, exc_info=False):
-    thread_name = threading.current_thread().name
-    full_msg = f"[{thread_name}] {msg}"
-    logging.error(full_msg, exc_info=exc_info)
-    try:
-        if threading.current_thread().name in ["MainThread", "CommandProcessor"]:
-            servicemanager.LogErrorMsg(str(full_msg))
-    except Exception as e:
-        logging.warning(f"Could not write error to Windows Event Log: {e}")
-
-# --- PowerShell Task Scheduler Helpers ---
-
-_TASK_NAME_PREFIX = "OOTB_UserLogon_"
-
-def run_powershell_command(command, log_output=True):
-    """Executes a PowerShell command and handles output/errors. Returns True on success."""
-    # Use log_info from the service instance if available, otherwise use root logger
-    logger = _service_instance.log_info if _service_instance else logging.info
-    error_logger = _service_instance.log_error if _service_instance else logging.error
-    logger(f"Executing PowerShell: {command}")
-    try:
-        # Using encoding important for non-ASCII usernames/paths
-        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:
-            logger(f"PowerShell STDOUT:\n{result.stdout.strip()}")
-        if log_output and result.stderr:
-            logger(f"PowerShell STDERR:\n{result.stderr.strip()}") # Log stderr as info
-        return True
-    except FileNotFoundError:
-        error_logger("'powershell.exe' not found. Cannot manage scheduled tasks.")
-        return False
-    except subprocess.CalledProcessError as e:
-        error_logger(f"PowerShell command failed (Exit Code {e.returncode}):")
-        error_logger(f"  Command: {e.cmd}")
-        if e.stdout: error_logger(f"  STDOUT: {e.stdout.strip()}")
-        if e.stderr: error_logger(f"  STDERR: {e.stderr.strip()}")
-        return False
-    except Exception as e:
-        error_logger(f"Unexpected error running PowerShell: {e}", exc_info=True)
-        return False
-
-def create_or_update_logon_task(username, task_command, python_executable):
-    """Creates or updates a scheduled task to run a command at user logon."""
-    logger = _service_instance.log_info if _service_instance else logging.info
-    error_logger = _service_instance.log_error if _service_instance else logging.error
-    task_name = f"{_TASK_NAME_PREFIX}{username}"
-    # Escape single quotes in paths and commands for PowerShell
-    safe_python_exe = python_executable.replace("'", "''")
-    # Ensure task_command is just the arguments, not the python exe itself
-    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: # Fallback if task_command doesn't start with python_exe
-         safe_task_command_args = task_command.replace(python_executable, "").strip().replace("'", "''")
-
-    safe_task_name = task_name.replace("'", "''")
-    safe_username = username.replace("'", "''") # Handle usernames with quotes?
-
-    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 # Indicate failure
-    }}
-    """
-    success = run_powershell_command(command)
-    if success:
-        logger(f"Successfully created/updated scheduled task '{task_name}' for user '{username}'.")
-    else:
-        error_logger(f"Failed to create/update scheduled task '{task_name}' for user '{username}'.")
-    return success
+# Move these inside the class later
+# def get_python_executable(): ...
+# def get_pip_executable(): ...
+
+# Define loggers at module level for use before instance exists?
+# Or handle carefully within instance methods.
 
+# --- PowerShell Task Scheduler Helpers --- (These will become methods) ---
 
-def remove_logon_task(username):
-    """Removes the logon scheduled task for a user."""
-    logger = _service_instance.log_info if _service_instance else logging.info
-    task_name = f"{_TASK_NAME_PREFIX}{username}"
-    safe_task_name = task_name.replace("'", "''")
-    command = f"Unregister-ScheduledTask -TaskName '{safe_task_name}' -Confirm:$false -ErrorAction SilentlyContinue"
-    run_powershell_command(command, log_output=False)
-    logger(f"Attempted removal of scheduled task '{task_name}' for user '{username}'.")
-    return True
+# _TASK_NAME_PREFIX = "OOTB_UserLogon_" # Move to class
+
+# def run_powershell_command(command, log_output=True): ...
+# def create_or_update_logon_task(username, task_command, python_executable): ...
+# def remove_logon_task(username): ...
 
 # --- End PowerShell Task Scheduler Helpers ---
 
@@ -238,6 +108,171 @@ 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):
+        thread_name = threading.current_thread().name
+        full_msg = f"[{thread_name}] {msg}"
+        logging.info(full_msg)
+        try:
+            if threading.current_thread().name in ["MainThread", "CommandProcessor"]:
+                 servicemanager.LogInfoMsg(str(full_msg))
+        except Exception as e:
+            # Log only to file if event log fails
+            logging.warning(f"(Instance) Could not write info to Windows Event Log: {e}")
+
+    def log_error(self, msg, exc_info=False):
+        thread_name = threading.current_thread().name
+        full_msg = f"[{thread_name}] {msg}"
+        logging.error(full_msg, exc_info=exc_info)
+        try:
+            if threading.current_thread().name in ["MainThread", "CommandProcessor"]:
+                servicemanager.LogErrorMsg(str(full_msg))
+        except Exception as e:
+            logging.warning(f"(Instance) Could not write error to Windows Event Log: {e}")
+    # --- End Instance Logging --- 
+
+    # --- Instance Helper Methods (Moved from module level) ---
+    def get_base_python_executable(self):
+        """Tries to find 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}")
+        # Normalize path for comparison
+        service_exe_lower = service_exe.lower()
+        
+        # Check if running as pythonservice.exe
+        if 'pythonservice.exe' in os.path.basename(service_exe_lower):
+            # Construct expected python.exe path in the same directory
+            dir_name = os.path.dirname(service_exe)
+            potential_python_exe = os.path.join(dir_name, 'python.exe')
+            self.log_info(f"get_base_python_executable: 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 at {potential_python_exe}")
+                # Quote if necessary
+                final_exe = potential_python_exe
+                if " " in final_exe and not final_exe.startswith('"'):
+                    return f'"{final_exe}"'
+                return final_exe
+            else:
+                 self.log_error(f"get_base_python_executable: Could not find python.exe near pythonservice.exe (checked {potential_python_exe}). Falling back to using {service_exe}.")
+                 # Fallback to original sys.executable (quoted if needed)
+                 if " " in service_exe and not service_exe.startswith('"'):
+                     return f'"{service_exe}"'
+                 return service_exe
+        else: # Not running as pythonservice.exe, assume sys.executable is correct
+            self.log_info(f"get_base_python_executable: sys.executable is not pythonservice.exe, using it directly.")
+            if " " in service_exe and not service_exe.startswith('"'):
+                 return f'"{service_exe}"'
+            return service_exe
+
+    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."""
+        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
+            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
+
+    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 ---
 
     def __init__(self, args):
         global _service_instance
@@ -247,15 +282,18 @@ class GuardService(win32serviceutil.ServiceFramework):
         self.server_thread = None
         self.command_queue = queue.Queue()
         self.command_processor_thread = None
-        self.session = requests.Session() # For status reporting
+        self.session = requests.Session()
 
-        self.python_exe = get_python_executable()
-        self.pip_command_base = get_pip_executable()
+        # 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}"
-        _service_instance = self # Set global reference
+        _service_instance = self
+        self.log_info(f"Service initialized. OOTB command set to: {self.ootb_command}")
 
     def SvcStop(self):
-        log_info(f"Service stop requested.")
+        self.log_info(f"Service stop requested.")
         self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
         self.is_running = False
         # Signal the command processor thread to stop
@@ -264,7 +302,7 @@ class GuardService(win32serviceutil.ServiceFramework):
         win32event.SetEvent(self.hWaitStop)
         # Stopping waitress gracefully from another thread is non-trivial.
         # We rely on the SCM timeout / process termination for now.
-        log_info(f"{_SERVICE_NAME} SvcStop: Stop signaled. Server thread will be terminated by SCM.")
+        self.log_info(f"{_SERVICE_NAME} SvcStop: Stop signaled. Server thread will be terminated by SCM.")
 
 
     def SvcDoRun(self):
@@ -272,51 +310,51 @@ class GuardService(win32serviceutil.ServiceFramework):
                               servicemanager.PYS_SERVICE_STARTED,
                               (self._svc_name_, ''))
         try:
-            log_info(f"{_SERVICE_NAME} starting.")
+            self.log_info(f"{_SERVICE_NAME} starting.")
             # Start the command processor thread
             self.command_processor_thread = threading.Thread(
                 target=self.process_commands, name="CommandProcessor", daemon=True)
             self.command_processor_thread.start()
-            log_info("Command processor thread started.")
+            self.log_info("Command processor thread started.")
 
             # Start the Flask server (via Waitress) in a separate thread
             self.server_thread = threading.Thread(
                 target=self.run_server, name="WebServerThread", daemon=True)
             self.server_thread.start()
-            log_info(f"Web server thread started, listening on {_LISTEN_HOST}:{_LISTEN_PORT}.")
+            self.log_info(f"Web server thread started, listening on {_LISTEN_HOST}:{_LISTEN_PORT}.")
 
-            log_info(f"{_SERVICE_NAME} running. Waiting for stop signal.")
+            self.log_info(f"{_SERVICE_NAME} running. Waiting for stop signal.")
             # Keep the main service thread alive waiting for stop signal
             win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE)
-            log_info(f"{_SERVICE_NAME} received stop signal in main thread.")
+            self.log_info(f"{_SERVICE_NAME} received stop signal in main thread.")
 
         except Exception as e:
-            log_error(f"Fatal error in SvcDoRun: {e}", exc_info=True)
+            self.log_error(f"Fatal error in SvcDoRun: {e}", exc_info=True)
             self.SvcStop() # Signal stop if possible
         finally:
-            log_info(f"{_SERVICE_NAME} SvcDoRun finished.")
+            self.log_info(f"{_SERVICE_NAME} SvcDoRun finished.")
 
 
     def run_server(self):
         """Runs the Flask app using Waitress."""
-        log_info(f"Waitress server starting on {_LISTEN_HOST}:{_LISTEN_PORT}")
+        self.log_info(f"Waitress server starting on {_LISTEN_HOST}:{_LISTEN_PORT}")
         try:
             serve(flask_app, host=_LISTEN_HOST, port=_LISTEN_PORT, threads=4)
-            log_info("Waitress server has stopped.") # Should only happen on shutdown
+            self.log_info("Waitress server has stopped.") # Should only happen on shutdown
         except Exception as e:
-            log_error(f"Web server thread encountered an error: {e}", exc_info=True)
+            self.log_error(f"Web server thread encountered an error: {e}", exc_info=True)
             # Consider signaling the main thread to stop if the web server fails critically
             # For now, just log the error.
 
 
     def process_commands(self):
         """Worker thread to process commands from the queue."""
-        log_info("Command processor thread starting.")
+        self.log_info("Command processor thread starting.")
         while self.is_running:
             try:
                 item = self.command_queue.get(block=True, timeout=1) # Add timeout to check is_running periodically
                 if item is None:
-                    log_info("Command processor received stop signal.")
+                    self.log_info("Command processor received stop signal.")
                     break # Exit loop
 
                 command_id, command = item
@@ -324,7 +362,7 @@ class GuardService(win32serviceutil.ServiceFramework):
                 target = command.get("target_user", "all_active")
                 status = "failed_unknown" # Default
 
-                log_info(f"Dequeued Command ID {command_id}: action='{action}', target='{target}'")
+                self.log_info(f"Dequeued Command ID {command_id}: action='{action}', target='{target}'")
 
                 try:
                     if action == "update":
@@ -334,10 +372,10 @@ class GuardService(win32serviceutil.ServiceFramework):
                     elif action == "start_ootb":
                         status = self.handle_start(target)
                     else:
-                        log_error(f"Unknown action in queue: {action}")
+                        self.log_error(f"Unknown action in queue: {action}")
                         status = "failed_unknown_action"
                 except Exception as handler_ex:
-                    log_error(f"Exception processing Command ID {command_id} ({action}): {handler_ex}", exc_info=True)
+                    self.log_error(f"Exception processing Command ID {command_id} ({action}): {handler_ex}", exc_info=True)
                     status = "failed_exception"
                 finally:
                     self.report_command_status(command_id, status)
@@ -347,17 +385,17 @@ class GuardService(win32serviceutil.ServiceFramework):
                 # Timeout occurred, just loop again and check self.is_running
                 continue
             except Exception as e:
-                 log_error(f"Error in command processing loop: {e}", exc_info=True)
+                 self.log_error(f"Error in command processing loop: {e}", exc_info=True)
                  if self.is_running:
                      time.sleep(5)
 
-        log_info("Command processor thread finished.")
+        self.log_info("Command processor thread finished.")
 
 
     def report_command_status(self, command_id, status, details=""):
         """Sends command status back to the server."""
         if not _SERVER_STATUS_REPORT_URL:
-            log_error("No server status report URL configured. Skipping report.")
+            self.log_error("No server status report URL configured. Skipping report.")
             return
 
         payload = {
@@ -366,41 +404,40 @@ class GuardService(win32serviceutil.ServiceFramework):
             "details": details,
             "machine_id": os.getenv('COMPUTERNAME', 'unknown_guard')
         }
-        log_info(f"Reporting status for command {command_id}: {status}")
+        self.log_info(f"Reporting status for command {command_id}: {status}")
         try:
             response = self.session.post(_SERVER_STATUS_REPORT_URL, json=payload, timeout=15)
             response.raise_for_status()
-            log_info(f"Status report for command {command_id} accepted by server.")
+            self.log_info(f"Status report for command {command_id} accepted by server.")
         except requests.exceptions.RequestException as e:
-            log_error(f"Failed to report status for command {command_id}: {e}")
+            self.log_error(f"Failed to report status for command {command_id}: {e}")
         except Exception as e:
-             log_error(f"Unexpected error reporting status for command {command_id}: {e}", exc_info=True)
+             self.log_error(f"Unexpected error reporting status for command {command_id}: {e}", exc_info=True)
 
-    # --- Command Handlers --- Copying full implementation from previous version
+    # --- Command Handlers --- Now call self. for helpers
 
     def handle_update(self):
-        log_info("Executing OOTB update...")
+        self.log_info("Executing OOTB update...")
         if not self.pip_command_base:
-            log_error("Cannot update: pip command not found.")
+            self.log_error("Cannot update: pip command not found.")
             return "failed_pip_not_found"
 
         update_command = f"{self.pip_command_base} install --upgrade --no-cache-dir {_PACKAGE_NAME}"
-        log_info(f"Running update command: {update_command}")
+        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')
-            log_info(f"Update successful: \nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}")
+            self.log_info(f"Update successful: \nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}")
             return "success"
         except subprocess.CalledProcessError as e:
-            log_error(f"Update failed (Exit Code {e.returncode}):\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}")
+            self.log_error(f"Update failed (Exit Code {e.returncode}):\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}")
             return f"failed_exit_{e.returncode}"
         except subprocess.TimeoutExpired:
-             log_error(f"Update command timed out.")
+             self.log_error(f"Update command timed out.")
              return "failed_timeout"
         except Exception as e:
-            log_error(f"Unexpected error during update: {e}", exc_info=True)
+            self.log_error(f"Unexpected error during update: {e}", exc_info=True)
             return "failed_exception"
 
-
     def _get_ootb_processes(self, target_user="all_active"):
         ootb_procs = []
         target_pid_list = []
@@ -412,10 +449,11 @@ class GuardService(win32serviceutil.ServiceFramework):
                       target_users.add(username.lower())
             else:
                  target_users.add(target_user.lower())
-
-            log_info(f"Searching for OOTB processes for users: {target_users}")
-
-            python_exe_path = self.python_exe.strip('"') # Get unquoted path for comparison
+            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('"') 
+            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']):
                 try:
@@ -426,22 +464,20 @@ class GuardService(win32serviceutil.ServiceFramework):
 
                     if proc_username in target_users:
                         cmdline = ' '.join(pinfo['cmdline']) if pinfo['cmdline'] else ''
-                        # Check if the process executable matches our python path AND module is in cmdline
-                        if pinfo['exe'] and pinfo['exe'] == python_exe_path and _OOTB_MODULE in cmdline:
-                            log_info(f"Found matching OOTB process: PID={pinfo['pid']}, User={pinfo['username']}, Cmd={cmdline}")
+                        # Check if the process executable matches our corrected python path AND module is in cmdline
+                        if pinfo['exe'] and pinfo['exe'] == python_exe_path_for_check and _OOTB_MODULE in cmdline:
+                            self.log_info(f"Found matching OOTB process: PID={pinfo['pid']}, User={pinfo['username']}, Cmd={cmdline}")
                             ootb_procs.append(proc)
                             target_pid_list.append(pinfo['pid'])
-
                 except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                     continue
-            log_info(f"Found {len(ootb_procs)} OOTB process(es) matching criteria: {target_pid_list}")
+            self.log_info(f"Found {len(ootb_procs)} OOTB process(es) matching criteria: {target_pid_list}")
         except Exception as e:
-             log_error(f"Error enumerating processes: {e}", exc_info=True)
+             self.log_error(f"Error enumerating processes: {e}", exc_info=True)
         return ootb_procs
 
-
     def handle_stop(self, target_user="all_active"):
-        log_info(f"Executing stop OOTB for target '{target_user}'...")
+        self.log_info(f"Executing stop OOTB for target '{target_user}'...")
         stop_results = {} # Track results per user {username: (task_status, immediate_status)}
         failed_users = set()
 
@@ -458,26 +494,26 @@ class GuardService(win32serviceutil.ServiceFramework):
                              if user:
                                  active_sessions[user.lower()] = session['SessionId']
                          except Exception as query_err:
-                             log_error(f"Could not query session {session['SessionId']} during stop: {query_err}")
+                             self.log_error(f"Could not query session {session['SessionId']} during stop: {query_err}")
             except Exception as user_enum_err:
-                  log_error(f"Error enumerating users/sessions during stop: {user_enum_err}", exc_info=True)
+                  self.log_error(f"Error enumerating users/sessions during stop: {user_enum_err}", exc_info=True)
                   return "failed_user_enumeration"
 
-            log_info(f"Stop target: '{target_user}'. Active sessions: {active_sessions}")
+            self.log_info(f"Stop target: '{target_user}'. Active sessions: {active_sessions}")
 
             target_users_normalized = set()
             if target_user == "all_active":
                   # Target only currently active users for stop all
                   target_users_normalized = set(active_sessions.keys())
-                  log_info(f"Stop targeting all active users: {target_users_normalized}")
+                  self.log_info(f"Stop targeting all active users: {target_users_normalized}")
             else:
                   # Target the specific user, regardless of active status (for task removal)
                   normalized_target = target_user.lower()
                   target_users_normalized.add(normalized_target)
-                  log_info(f"Stop targeting specific user: {normalized_target}")
+                  self.log_info(f"Stop targeting specific user: {normalized_target}")
 
             if not target_users_normalized:
-                  log_info("No target users identified for stop.")
+                  self.log_info("No target users identified for stop.")
                   return "failed_no_target_users" # Or success if none were targeted?
 
             # --- Process each target user ---
@@ -486,15 +522,15 @@ class GuardService(win32serviceutil.ServiceFramework):
                  immediate_stop_status = "stop_not_attempted"
                  stopped_count = 0
 
-                 log_info(f"Processing stop for user '{user}'...")
+                 self.log_info(f"Processing stop for user '{user}'...")
 
                  # 1. Always try to remove the scheduled task
                  try:
                      # remove_logon_task always returns True for now, just logs attempt
-                     remove_logon_task(user)
+                     self.remove_logon_task(user)
                      task_removed_status = "task_removed_attempted"
                  except Exception as task_err:
-                      log_error(f"Exception removing scheduled task for {user}: {task_err}", exc_info=True)
+                      self.log_error(f"Exception removing scheduled task for {user}: {task_err}", exc_info=True)
                       task_removed_status = "task_exception"
                       failed_users.add(user)
                       # Continue to try and stop process if active
@@ -504,37 +540,37 @@ class GuardService(win32serviceutil.ServiceFramework):
 
                  if is_active:
                      immediate_stop_status = "stop_attempted"
-                     log_info(f"User '{user}' is active. Attempting to terminate OOTB process(es)...")
+                     self.log_info(f"User '{user}' is active. Attempting to terminate OOTB process(es)...")
                      # Pass the specific username to _get_ootb_processes
                      procs_to_stop = self._get_ootb_processes(user)
 
                      if not procs_to_stop:
-                         log_info(f"No running OOTB processes found for active user '{user}'.")
+                         self.log_info(f"No running OOTB processes found for active user '{user}'.")
                          immediate_stop_status = "stop_skipped_not_running"
                      else:
-                         log_info(f"Found {len(procs_to_stop)} process(es) for user '{user}' to stop.")
+                         self.log_info(f"Found {len(procs_to_stop)} process(es) for user '{user}' to stop.")
                          for proc in procs_to_stop:
                              try:
                                  pid = proc.pid # Get pid before potential termination
                                  username = proc.info.get('username', 'unknown_user')
-                                 log_info(f"Terminating process PID={pid}, User={username}")
+                                 self.log_info(f"Terminating process PID={pid}, User={username}")
                                  proc.terminate()
                                  try:
                                      proc.wait(timeout=3)
-                                     log_info(f"Process PID={pid} terminated successfully.")
+                                     self.log_info(f"Process PID={pid} terminated successfully.")
                                      stopped_count += 1
                                  except psutil.TimeoutExpired:
-                                     log_error(f"Process PID={pid} did not terminate gracefully, killing.")
+                                     self.log_error(f"Process PID={pid} did not terminate gracefully, killing.")
                                      proc.kill()
                                      stopped_count += 1
                              except psutil.NoSuchProcess:
-                                  log_info(f"Process PID={pid} already terminated.")
+                                  self.log_info(f"Process PID={pid} already terminated.")
                                   # Don't increment stopped_count here as we didn't stop it now
                              except psutil.AccessDenied:
-                                 log_error(f"Access denied trying to terminate process PID={pid}.")
+                                 self.log_error(f"Access denied trying to terminate process PID={pid}.")
                                  failed_users.add(user) # Mark user as failed if stop fails
                              except Exception as e:
-                                 log_error(f"Error stopping process PID={pid}: {e}", exc_info=True)
+                                 self.log_error(f"Error stopping process PID={pid}: {e}", exc_info=True)
                                  failed_users.add(user) # Mark user as failed
 
                          # Determine status based on how many were found vs stopped
@@ -546,7 +582,7 @@ class GuardService(win32serviceutil.ServiceFramework):
                               immediate_stop_status = f"stop_partial_terminated_{stopped_count}_of_{len(procs_to_stop)}"
 
                  else: # User not active
-                     log_info(f"User '{user}' is not active. Skipping immediate process stop (task removal attempted).")
+                     self.log_info(f"User '{user}' is not active. Skipping immediate process stop (task removal attempted).")
                      immediate_stop_status = "stop_skipped_inactive"
 
                  # Record final results for this user
@@ -559,7 +595,7 @@ class GuardService(win32serviceutil.ServiceFramework):
             if not stop_results: final_status = "no_targets_processed"
             if len(failed_users) == total_processed and total_processed > 0 : final_status = "failed"
 
-            log_info(f"Finished stopping OOTB. Overall Status: {final_status}. Results: {stop_results}")
+            self.log_info(f"Finished stopping OOTB. Overall Status: {final_status}. Results: {stop_results}")
             try:
                 details = json.dumps(stop_results)
             except Exception:
@@ -567,12 +603,12 @@ class GuardService(win32serviceutil.ServiceFramework):
             return f"{final_status}::{details}" # Use :: as separator
 
         except Exception as e:
-             log_error(f"Error during combined stop OOTB process: {e}", exc_info=True)
+             self.log_error(f"Error during combined stop OOTB process: {e}", exc_info=True)
              return "failed_exception"
 
 
     def handle_start(self, target_user="all_active"):
-        log_info(f"Executing start OOTB for target '{target_user}'...")
+        self.log_info(f"Executing start OOTB for target '{target_user}'...")
         start_results = {} # Track results per user {username: (task_status, immediate_status)}
         failed_users = set()
 
@@ -594,18 +630,18 @@ class GuardService(win32serviceutil.ServiceFramework):
                             if user:
                                 active_sessions[user.lower()] = session['SessionId']
                         except Exception as query_err:
-                            log_error(f"Could not query session {session['SessionId']}: {query_err}")
+                            self.log_error(f"Could not query session {session['SessionId']}: {query_err}")
             except Exception as user_enum_err:
-                 log_error(f"Error enumerating users/sessions: {user_enum_err}", exc_info=True)
+                 self.log_error(f"Error enumerating users/sessions: {user_enum_err}", exc_info=True)
                  return "failed_user_enumeration"
 
-            log_info(f"Found active user sessions: {active_sessions}")
+            self.log_info(f"Found active user sessions: {active_sessions}")
 
             target_users_normalized = set()
             if target_user == "all_active":
                  # If targeting all_active, only target those CURRENTLY active
                  target_users_normalized = set(active_sessions.keys())
-                 log_info(f"Targeting all active users: {target_users_normalized}")
+                 self.log_info(f"Targeting all active users: {target_users_normalized}")
             else:
                  normalized_target = target_user.lower()
                  # Check if the target user actually exists on the system, even if inactive
@@ -613,13 +649,13 @@ class GuardService(win32serviceutil.ServiceFramework):
                  # Let's assume admin provides a valid username for specific targeting.
                  # if normalized_target in all_system_users: # Removing this check, assume valid user input
                  target_users_normalized.add(normalized_target)
-                 log_info(f"Targeting specific user: {normalized_target}")
+                 self.log_info(f"Targeting specific user: {normalized_target}")
                  # else:
                  #     log_error(f"Target user '{target_user}' does not appear to exist on this system based on psutil.")
                  #     return "failed_user_does_not_exist"
 
             if not target_users_normalized:
-                 log_info("No target users identified (or none active for 'all_active').")
+                 self.log_info("No target users identified (or none active for 'all_active').")
                  # If target was specific user but they weren't found active, still try task?
                  # Let's proceed to task creation anyway for specific user case.
                  if target_user != "all_active": target_users_normalized.add(target_user.lower())
@@ -639,8 +675,8 @@ class GuardService(win32serviceutil.ServiceFramework):
                              running_procs_by_user[user_lower] = running_procs_by_user.get(user_lower, 0) + 1
                     except Exception: pass
             except Exception as e:
-                 log_error(f"Error checking existing processes: {e}")
-            log_info(f"Users currently running OOTB: {running_procs_by_user}")
+                 self.log_error(f"Error checking existing processes: {e}")
+            self.log_info(f"Users currently running OOTB: {running_procs_by_user}")
 
             # --- Process each target user ---
             for user in target_users_normalized:
@@ -648,14 +684,14 @@ class GuardService(win32serviceutil.ServiceFramework):
                 immediate_start_status = "start_not_attempted"
                 token = None # Ensure token is reset/defined
 
-                log_info(f"Processing start for user '{user}'...")
+                self.log_info(f"Processing start for user '{user}'...")
 
                 # 1. Always try to create/update the scheduled task
                 try:
-                    task_created = create_or_update_logon_task(user, self.ootb_command, self.python_exe)
+                    task_created = self.create_or_update_logon_task(user, self.ootb_command, self.python_exe)
                     task_created_status = "task_success" if task_created else "task_failed"
                 except Exception as task_err:
-                     log_error(f"Exception creating/updating scheduled task for {user}: {task_err}", exc_info=True)
+                     self.log_error(f"Exception creating/updating scheduled task for {user}: {task_err}", exc_info=True)
                      task_created_status = "task_exception"
                      failed_users.add(user)
                      # Continue to potentially try immediate start IF user is active?
@@ -671,7 +707,7 @@ class GuardService(win32serviceutil.ServiceFramework):
                 if is_active:
                     if not is_running:
                         immediate_start_status = "start_attempted"
-                        log_info(f"User '{user}' is active and not running OOTB. Attempting immediate start...")
+                        self.log_info(f"User '{user}' is active and not running OOTB. Attempting immediate start...")
                         try:
                             session_id = active_sessions[user]
                             token = win32ts.WTSQueryUserToken(session_id)
@@ -686,21 +722,21 @@ class GuardService(win32serviceutil.ServiceFramework):
                                 token, self.python_exe, self.ootb_command,
                                 None, None, False, creation_flags, env, user_profile_dir, startup
                             )
-                            log_info(f"CreateProcessAsUser call succeeded for user '{user}' (PID: {dwPid}). Checking existence...")
+                            self.log_info(f"CreateProcessAsUser call succeeded for user '{user}' (PID: {dwPid}). Checking existence...")
                             win32api.CloseHandle(hProcess)
                             win32api.CloseHandle(hThread)
 
                             time.sleep(1)
                             if psutil.pid_exists(dwPid):
-                                log_info(f"Immediate start succeeded for user '{user}' (PID {dwPid}).")
+                                self.log_info(f"Immediate start succeeded for user '{user}' (PID {dwPid}).")
                                 immediate_start_status = "start_success"
                             else:
-                                log_error(f"Immediate start failed for user '{user}': Process {dwPid} exited immediately.")
+                                self.log_error(f"Immediate start failed for user '{user}': Process {dwPid} exited immediately.")
                                 immediate_start_status = "start_failed_exited"
                                 failed_users.add(user)
 
                         except Exception as proc_err:
-                             log_error(f"Exception during immediate start for user '{user}': {proc_err}", exc_info=True)
+                             self.log_error(f"Exception during immediate start for user '{user}': {proc_err}", exc_info=True)
                              immediate_start_status = "start_failed_exception"
                              failed_users.add(user)
                         finally:
@@ -708,10 +744,10 @@ class GuardService(win32serviceutil.ServiceFramework):
                                   try: win32api.CloseHandle(token)
                                   except: pass
                     else: # User is active but already running
-                        log_info(f"User '{user}' is active but OOTB is already running. Skipping immediate start.")
+                        self.log_info(f"User '{user}' is active but OOTB is already running. Skipping immediate start.")
                         immediate_start_status = "start_skipped_already_running"
                 else: # User is not active
-                     log_info(f"User '{user}' is not active. Skipping immediate start (task created/updated).")
+                     self.log_info(f"User '{user}' is not active. Skipping immediate start (task created/updated).")
                      immediate_start_status = "start_skipped_inactive"
                 
                 # Record final results for this user
@@ -732,7 +768,7 @@ class GuardService(win32serviceutil.ServiceFramework):
                 else:
                     final_status = "failed_task_user_inactive"
 
-            log_info(f"Finished starting OOTB. Overall Status: {final_status}. Results: {start_results}")
+            self.log_info(f"Finished starting OOTB. Overall Status: {final_status}. Results: {start_results}")
             # Return detailed results as a JSON string for easier parsing/logging server-side
             try: 
                 details = json.dumps(start_results)
@@ -741,13 +777,13 @@ class GuardService(win32serviceutil.ServiceFramework):
             return f"{final_status}::{details}" 
 
         except Exception as e:
-             log_error(f"Error during combined start OOTB process: {e}", exc_info=True)
+             self.log_error(f"Error during combined start OOTB process: {e}", exc_info=True)
              return "failed_exception"
 
 # --- Main Execution Block ---
 if __name__ == '__main__':
     if len(sys.argv) > 1 and sys.argv[1] == 'debug':
-        log_info("Starting service in debug mode...")
+        self.log_info("Starting service in debug mode...")
         print(f"Running Flask server via Waitress on {_LISTEN_HOST}:{_LISTEN_PORT} for debugging...")
         print("Service logic (command processing) will NOT run in this mode.")
         print("Use this primarily to test the '/command' endpoint receiving POSTs.")

computer_use_ootb_internal-0.0.120/deploy.sh

@@ -1,3 +0,0 @@
-rm -rf dist
-python -m build
-python -m twine upload dist/*