computer-use-ootb-internal 0.0.147__tar.gz → 0.0.148__tar.gz

{computer_use_ootb_internal-0.0.147 → computer_use_ootb_internal-0.0.148}/PKG-INFO

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

{computer_use_ootb_internal-0.0.147 → computer_use_ootb_internal-0.0.148}/pyproject.toml

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

{computer_use_ootb_internal-0.0.147 → computer_use_ootb_internal-0.0.148}/src/computer_use_ootb_internal/app_teachmode.py

@@ -123,7 +123,6 @@ class SharedState:
         self.trace_id = args.trace_id
         self.api_keys = args.api_keys
         self.server_url = args.server_url
-        self.port = getattr(args, 'port', None)
         self.message_queue = []
         self.is_processing = False
         self.should_stop = False
@@ -207,8 +206,6 @@ async def update_parameters(request: Request):
         shared_state.trace_id = getattr(shared_state.args, 'trace_id', "build_scroll_combat")
         shared_state.api_keys = getattr(shared_state.args, 'api_keys', "sk-proj-1234567890")
         shared_state.server_url = getattr(shared_state.args, 'server_url', "http://ec2-44-234-43-86.us-west-2.compute.amazonaws.com")
-        # Include the specified port if available
-        shared_state.port = getattr(shared_state.args, 'port', None)
         
         log_ootb_request(shared_state.server_url, "update_params", data)
 
@@ -496,8 +493,9 @@ def main():
     parser.add_argument("--trace_id", type=str, default="build_scroll_combat", help="Trace ID for the session")
     parser.add_argument("--api_keys", type=str, default="sk-proj-1234567890", help="API keys")
     parser.add_argument("--server_url", type=str, default="http://ec2-44-234-43-86.us-west-2.compute.amazonaws.com", help="Server URL for the session")
-    # Add argument to directly specify the port
-    parser.add_argument("-p", "--port", type=int, default=None, help="Specify the exact port to run the server on, overriding username-based calculation.")
+    # Add arguments for port override and target user
+    parser.add_argument("-p", "--port", type=int, default=None, help="Specify the port to run the server on, overriding user-based calculation.")
+    parser.add_argument("--target_user", type=str, default=None, help="Specify the target username for port calculation if --port is not given.")
 
     args = parser.parse_args()
 
@@ -509,49 +507,38 @@ def main():
     if not hasattr(args, 'trace_id'): args.trace_id = "unknown_trace"
     if not hasattr(args, 'api_keys'): args.api_keys = "none"
     if not hasattr(args, 'server_url'): args.server_url = "none"
-    # Ensure the port arg exists
-    if not hasattr(args, 'port'): args.port = None
 
     shared_state = SharedState(args)
     rate_limiter = RateLimiter(interval_seconds=2) # Re-initialize rate limiter
     logging.info(f"Shared state initialized for user: {args.user_id}")
 
-    # --- Port Determination --- 
-    port = args.port # Get port from argument first
+    # --- Port Calculation Logic ---
+    port = 7888 # Default port
     host = "0.0.0.0" # Listen on all interfaces
-
-    if port is not None:
+    
+    if args.port is not None:
+        port = args.port
         logging.info(f"Using specified port from --port argument: {port}")
-    elif platform.system() == "Windows":
-        # Fallback to username calculation ONLY if --port was not provided
-        port = 7888 # Default port for fallback calculation
+    elif platform.system() == "Windows" and args.target_user is not None:
         try:
-            username_to_check = os.environ.get("USERNAME")
-            if username_to_check:
-                username = username_to_check.lower()
-                logging.info(f"Determining port based on current user environment: {username}")
-                if username == "altair":
-                    port = 14000
-                elif username.startswith("guest") and username[5:].isdigit():
-                    num = int(username[5:])
-                    if 1 <= num <= 10:
-                        port = 14000 + num
-                    else:
-                        logging.warning(f"Guest user number {num} out of range (1-10), using default port {port}.")
-                elif username == "administrator":
-                    logging.info(f"Running as Administrator, using default port {port}.")
+            # Use the --target_user argument for calculation
+            username = args.target_user.lower()
+            logging.info(f"Determining port based on Windows username from --target_user: {username}")
+            if username == "altair":
+                port = 14000
+            elif username.startswith("guest") and username[5:].isdigit():
+                num = int(username[5:])
+                if 1 <= num <= 10: # Assuming max 10 guests for this range
+                    port = 14000 + num
                 else:
-                    logging.info(f"Username '{username}' doesn't match specific rules, using default port {port}.")
+                     logging.warning(f"Guest user number {num} out of range (1-10), using default port {port}.")
             else:
-                logging.warning(f"USERNAME environment variable not found. Using default port {port}.")
+                logging.info(f"Username '{username}' doesn't match specific rules, using default port {port}.")
         except Exception as e:
-            logging.error(f"Error calculating port from username: {e}. Using default port {port}.", exc_info=True)
+             logging.error(f"Error determining port from --target_user '{args.target_user}': {e}. Using default port {port}.", exc_info=True)
     else:
-        # Non-windows, or Windows with no username found, and no --port arg
-        port = 7888 # Default port
-        logging.info(f"Not on Windows or username not found, using default port {port}.")
-
-    # --- End Port Determination ---
+         logging.info(f"--port not specified, and not on Windows or --target_user not specified. Using default port {port}.")
+    # --- End Port Calculation ---
 
     logging.info(f"Final Host={host}, Port={port}")
 

{computer_use_ootb_internal-0.0.147 → computer_use_ootb_internal-0.0.148}/src/computer_use_ootb_internal/guard_service.py

@@ -52,9 +52,6 @@ _service_instance = None
 # --- Flask App Definition ---
 flask_app = Flask(__name__)
 
-# Default port constant
-_DEFAULT_OOTB_PORT = 7888
-
 @flask_app.route('/command', methods=['POST'])
 def receive_command():
     global _service_instance
@@ -666,7 +663,9 @@ class GuardService(win32serviceutil.ServiceFramework):
         trigger_results = {}
         for user in target_users_normalized:
              self.log_info(f"Calling internal start trigger for user: {user}")
-             # Queue the start action using the command queue
+             # Call the core logic directly (this is now synchronous within the handler)
+             # Or queue it? Queuing might be better to avoid blocking the handler if many users.
+             # Let's stick to the queue approach from the internal endpoint:
              internal_command = {
                 "action": "_internal_start_ootb",
                 "target_user": user
@@ -683,15 +682,45 @@ class GuardService(win32serviceutil.ServiceFramework):
 
 
     def _trigger_start_for_user(self, username):
-        """Core logic to start OOTB for a single user using elevated scheduled task."""
+        """Core logic to start OOTB for a single user. Called internally."""
         user = username.lower() # Ensure lowercase
         self.log_info(f"Internal trigger: Starting OOTB check for user '{user}'...")
-        task_name = f"OOTB_UserConnect_{user}" # Task name used for start
+        task_created_status = "task_unknown"
+        immediate_start_status = "start_not_attempted"
         final_status = "failed_unknown"
+        calculated_port = 7888 # Default port
+
+        # --- Calculate Port based on username (mirroring app_teachmode logic) ---
+        try:
+            if user == "altair":
+                calculated_port = 14000
+            elif user.startswith("guest") and user[5:].isdigit():
+                num = int(user[5:])
+                if 1 <= num <= 10:
+                    calculated_port = 14000 + num
+                else:
+                    self.log_warning(f"Internal trigger: User 'guest{num}' out of range (1-10), using default port {calculated_port} for launch.")
+            # else: use default 7888
+            self.log_info(f"Internal trigger: Calculated port {calculated_port} for user '{user}'.")
+        except Exception as port_calc_e:
+            self.log_error(f"Internal trigger: Error calculating port for user '{user}': {port_calc_e}. Using default port {calculated_port}.")
+        # --- End Port Calculation ---
+
 
         try:
-            # 1. Check if user is active (required to trigger task meaningfully)
+            # 1. Ensure scheduled task exists (still useful fallback/persistence)
+            try:
+                task_created = self.create_or_update_logon_task(user)
+                task_created_status = "task_success" if task_created else "task_failed"
+            except Exception as task_err:
+                 self.log_error(f"Internal trigger: Exception creating/updating task for {user}: {task_err}", exc_info=True)
+                 task_created_status = "task_exception"
+                 # Don't necessarily fail the whole operation yet
+            
+            # 2. Check if user is active
+            active_sessions = {} # Re-check active sessions specifically for this user
             session_id = None
+            token = None
             is_active = False
             try:
                 sessions = win32ts.WTSEnumerateSessions(win32ts.WTS_CURRENT_SERVER_HANDLE)
@@ -707,69 +736,89 @@ class GuardService(win32serviceutil.ServiceFramework):
                         except Exception: pass # Ignore errors querying other sessions
             except Exception as e:
                  self.log_error(f"Internal trigger: Error checking active sessions for {user}: {e}")
-                 # If we can't check, assume inactive for safety?
-                 return "failed_session_check" # Exit if we cannot verify active state
-
+                 # Continue, assume inactive if check failed?
+            
             if not is_active:
-                self.log_info(f"Internal trigger: User '{user}' is not active. Skipping immediate start via task.")
-                # Still ensure task exists for future logins
-                try:
-                    task_created = self.create_or_update_logon_task(user)
-                    if not task_created:
-                        self.log_error(f"Failed to create/update logon task for inactive user {user}")
-                        # Maybe return a specific status?
-                except Exception as task_err:
-                     self.log_error(f"Exception creating/updating task for inactive user {user}: {task_err}")
-                return "skipped_inactive_user"
-
-            # 2. Check if already running for this active user
+                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
+                return final_status # Exit early if inactive
+
+            # 3. Check if already running for this active user
             is_running = False
             try:
                 running_procs = self._get_ootb_processes(user)
                 if running_procs:
                      is_running = True
-                     self.log_info(f"Internal trigger: OOTB already running for active user '{user}'. Skipping task start.")
-                     final_status = "success_already_running"
+                     self.log_info(f"Internal trigger: OOTB already running for active user '{user}'. Skipping immediate start.")
+                     immediate_start_status = "start_skipped_already_running"
+                     final_status = "success_already_running" # Considered success
                      return final_status # Exit early if already running
             except Exception as e:
                  self.log_error(f"Internal trigger: Error checking existing processes for {user}: {e}")
-                 # Proceed with start attempt despite error?
+                 # Continue and attempt start despite error?
 
-            # 3. Ensure the scheduled task exists and is configured correctly (redundant but safe)
-            self.log_info(f"Internal trigger: Ensuring elevated task '{task_name}' exists for user '{user}'...")
-            try:
-                task_created = self.create_or_update_logon_task(user)
-                if not task_created:
-                    self.log_error(f"Internal trigger: Failed to create/update required task '{task_name}'. Cannot start.")
-                    return "failed_task_creation"
-            except Exception as task_err:
-                 self.log_error(f"Internal trigger: Exception creating/updating task '{task_name}': {task_err}", exc_info=True)
-                 return "failed_task_exception"
+            # 4. Attempt immediate start (User is active and not running)
+            immediate_start_status = "start_attempted"
+            self.log_info(f"Internal trigger: User '{user}' is active and not running. Attempting immediate start via PowerShell elevation...")
+            
+            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 # Exit early if executable missing
 
-            # 4. Attempt immediate start by running the scheduled task
-            self.log_info(f"Internal trigger: User '{user}' is active and OOTB not running. Attempting start via Start-ScheduledTask '{task_name}'...")
-            ps_command = f'Start-ScheduledTask -TaskName "{task_name}"'
             try:
-                success = self.run_powershell_command(ps_command)
-                if success:
-                     self.log_info(f"Internal trigger: Successfully executed Start-ScheduledTask for '{task_name}'.")
-                     # We assume success here; actual process start confirmation is difficult async
-                     final_status = "success_task_started"
-                     # Check process again after a delay?
-                     time.sleep(3) # Give it a moment to start
-                     if self._get_ootb_processes(user):
-                          self.log_info(f"Internal trigger: Confirmed OOTB process running for user '{user}' after task start.")
-                     else:
-                          self.log_warning(f"Internal trigger: OOTB process NOT detected for user '{user}' shortly after task start. Task might have failed internally.")
-                          final_status = "warning_start_task_no_process_detected"
-                else:
-                     self.log_error(f"Internal trigger: Failed to execute Start-ScheduledTask for '{task_name}'. See PowerShell logs.")
-                     final_status = "failed_start_task_command"
+                token = win32ts.WTSQueryUserToken(session_id)
+                env = win32profile.CreateEnvironmentBlock(token, False)
+                startup = win32process.STARTUPINFO()
+                creation_flags = win32con.CREATE_NO_WINDOW # Hide intermediate powershell/cmd window if possible
+                
+                # Command to run PowerShell, which then elevates the target executable
+                target_exe_for_ps = self.target_executable_path.strip('"').replace("'", "''") # Path for PS string, escape single quotes
+                arguments_for_ps = f"--port {calculated_port} --target_user '{user}'" # Pass calculated port and target user
+                powershell_command = (
+                    f'Start-Process -FilePath "{target_exe_for_ps}" '
+                    f'-ArgumentList "{arguments_for_ps}" -Verb RunAs'
+                )
+                # Escape the command for cmd.exe /c
+                escaped_ps_command = powershell_command.replace('"', '\\"')
+                
+                # Use cmd /c to launch powershell - this seems more reliable with CreateProcessAsUser sometimes
+                # lpCommandLine = f'powershell.exe -ExecutionPolicy Bypass -NoProfile -Command "{powershell_command}"'
+                lpCommandLine = f'cmd.exe /c "powershell.exe -ExecutionPolicy Bypass -NoProfile -Command \\"{escaped_ps_command}\\""'
 
-            except Exception as start_task_err:
-                 self.log_error(f"Internal trigger: Exception running Start-ScheduledTask for '{task_name}': {start_task_err}", exc_info=True)
-                 final_status = "failed_start_task_exception"
+                lpApplicationName = None # Must be None if using lpCommandLine
+                cwd = os.path.dirname(target_exe_for_ps) if os.path.dirname(target_exe_for_ps) else None
 
+                # Log details before call
+                self.log_info(f"Internal trigger: Calling CreateProcessAsUser:")
+                self.log_info(f"  lpCommandLine: {lpCommandLine}")
+                self.log_info(f"  lpCurrentDirectory: {cwd if cwd else 'Default'}")
+                
+                hProcess, hThread, dwPid, dwTid = win32process.CreateProcessAsUser(
+                    token, lpApplicationName, lpCommandLine, None, None, False,
+                    creation_flags, env, cwd, startup
+                )
+                # We get the PID of cmd.exe/powershell.exe here, not the final elevated process.
+                # We can't easily track the elevated process PID across the UAC boundary.
+                self.log_info(f"Internal trigger: CreateProcessAsUser call to initiate elevation succeeded for user '{user}' (Launcher PID: {dwPid}). UAC prompt expected if needed.")
+                win32api.CloseHandle(hProcess)
+                win32api.CloseHandle(hThread)
+
+                # Assume success if the call didn't raise an exception.
+                # We cannot easily verify if the *elevated* process actually started.
+                immediate_start_status = "start_elevation_initiated"
+                final_status = "success_elevation_initiated" # Report success based on initiating the elevation
+
+            except Exception as proc_err:
+                 self.log_error(f"Internal trigger: Exception during CreateProcessAsUser for elevation attempt (user '{user}'): {proc_err}", exc_info=True)
+                 immediate_start_status = "start_failed_exception"
+                 final_status = "failed_start_exception"
+            finally:
+                 if token: win32api.CloseHandle(token)
+            
+            # Combine results (mostly determined by start attempt now)
+            # Example: final_status = f"{task_created_status}_{immediate_start_status}"
             return final_status
 
         except Exception as e:
@@ -792,32 +841,32 @@ class GuardService(win32serviceutil.ServiceFramework):
              python_exe = f'"{python_exe}"'
 
         task_name = f"OOTB_UserConnect_{username}"
-        # Calculate the port for this user
-        calculated_port = self._calculate_port_for_user(username)
-
-        # Action: Run the target executable directly, passing the calculated port
-        action_executable = self.target_executable_path
-        action_arguments = f'--port {calculated_port}' # Use --port or -p
+        # 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 executable (its own directory)
+        # Working directory for the script (likely its own directory)
         try:
-            exe_dir = os.path.dirname(self.target_executable_path.strip('"'))
-            if not exe_dir: exe_dir = "."
-            safe_working_directory = exe_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 OOTB executable 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}"
-        # Run as the specified user, with Highest privileges
-        $principal = New-ScheduledTaskPrincipal -UserId "{username}" -LogonType Interactive -RunLevel Highest
+        $principal = New-ScheduledTaskPrincipal -UserId "{username}" -LogonType Interactive
         
-        # Action: Run the OOTB executable directly with args
+        # Action: Run python signal script
         $action = New-ScheduledTaskAction -Execute '{safe_action_executable}' -Argument '{safe_action_arguments}'
         {working_directory_setting}
 
@@ -889,9 +938,7 @@ class GuardService(win32serviceutil.ServiceFramework):
         return True
 
     def _find_signal_script(self):
-        """Finds the signal_connection.py script relative to this service file. DEPRECATED?"""
-        # This might no longer be needed if the task directly runs the main executable
-        self.log_warning("_find_signal_script called - this might be deprecated.")
+        """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")
@@ -908,30 +955,6 @@ class GuardService(win32serviceutil.ServiceFramework):
             self.log_error(f"Error finding signal script: {e}")
             return None
 
-    def _calculate_port_for_user(self, username):
-        """Calculates the target port based on the username."""
-        port = _DEFAULT_OOTB_PORT # Start with default
-        username_lower = username.lower()
-        self.log_info(f"Calculating port for username: {username_lower}")
-        try:
-            if username_lower == "altair":
-                port = 14000
-            elif username_lower.startswith("guest") and username_lower[5:].isdigit():
-                num = int(username_lower[5:])
-                if 1 <= num <= 10:
-                    port = 14000 + num
-                else:
-                    self.log_warning(f"Guest user number {num} out of range (1-10) for port calculation, using default {port}.")
-            # Add Administrator or other specific users if needed
-            # elif username_lower == "administrator":
-            #     port = 14999 # Example
-            else:
-                self.log_info(f"Username '{username_lower}' doesn't match specific rules, using default port {port}.")
-        except Exception as e:
-            self.log_error(f"Error during port calculation for {username_lower}: {e}. Using default {port}.", exc_info=True)
-        self.log_info(f"Calculated port {port} for user {username_lower}")
-        return port
-
 # --- Main Execution Block ---
 if __name__ == '__main__':
     if len(sys.argv) > 1 and sys.argv[1] == 'debug':