computer-use-ootb-internal 0.0.110__py3-none-any.whl → 0.0.112__py3-none-any.whl

computer_use_ootb_internal/app_teachmode.py

@@ -8,6 +8,9 @@ import platform  # Add platform import
 import pyautogui  # Add pyautogui import
 import webbrowser # Add webbrowser import
 import os # Import os for path joining
+import logging # Import logging
+import importlib # For dynamic imports
+import pkgutil # To find modules
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
@@ -90,67 +93,47 @@ class SharedState:
 shared_state = None
 rate_limiter = RateLimiter(interval_seconds=2)
 
-# Add the new prepare_environment function here
+# Set up logging for this module
+log = logging.getLogger(__name__)
+
 def prepare_environment(state):
-    """Prepares the environment before starting the main processing loop, e.g., opening specific apps."""
-    if platform.system() == "Windows":
-        # Assuming Star Rail mode is indicated by user_id containing "star_rail"
-        # You might need to adjust this condition based on the actual logic in run_teachmode_args
-        is_star_rail = "star_rail" in state.user_id.lower() or \
-                       "star_rail" in state.trace_id.lower() or \
-                       "hero_case" in state.trace_id.lower()
-        
-        if is_star_rail:
-            print("Star Rail mode detected on Windows. Opening Edge browser...")
-            url = "https://sr.mihoyo.com/cloud/#/"
-            browser_opened = False
-            try:
-                # Use only webbrowser.open
-                print(f"Attempting to open {url} using webbrowser.open()...")
-                if webbrowser.open(url):
-                    print(f"Successfully requested browser to open {url} via webbrowser.open().")
-                    browser_opened = True
-                else:
-                    print("webbrowser.open() returned False, indicating potential failure.")
-
-                if not browser_opened:
-                    print("ERROR: Failed to confirm browser opening via webbrowser.open().")
-                    # Still proceed to click attempt
-
-                # Add pyautogui click after attempting to open the browser
-                print("Proceeding with pyautogui actions...")
-                time.sleep(5) # Wait time for the browser to load
-                
-                # Print detected screen size
-                screen_width, screen_height = pyautogui.size()
-                print(f"Detected screen size: {screen_width}x{screen_height}")
-
-                click_x = int(screen_width * (1036 / 1280))
-                click_y = int(screen_height * (500 / 720))
-                print(f"Calculated click coordinates: ({click_x}, {click_y})")
-
-                # Disable failsafe before clicking
-                pyautogui.FAILSAFE = False
-                print("PyAutoGUI failsafe temporarily disabled.")
-
-                print(f"Clicking at coordinates: ({click_x}, {click_y})")
-                pyautogui.click(click_x, click_y)
-                time.sleep(2)
-                pyautogui.click(click_x, click_y)
-                
-                # Re-enable failsafe (optional, as script might end anyway)
-                # pyautogui.FAILSAFE = True 
-                # print("PyAutoGUI failsafe re-enabled.")
-
-            except Exception as e:
-                print(f"Error during environment preparation (browser/click): {e}")
-            finally:
-                 # Ensure failsafe is re-enabled if an error occurs after disabling it
-                 pyautogui.FAILSAFE = True
-                 print("PyAutoGUI failsafe re-enabled.")
-    else:
-        # Placeholder for potential preparations on other OS or non-Star Rail modes
-        print("Environment preparation: No specific actions required for this OS/mode.")
+    """Dynamically loads and runs preparation logic based on software name."""
+    # TODO: Replace hardcoded software name with value from shared_state when available
+    software_name = "star rail"
+    # Normalize the software name to be a valid Python module name
+    # Replace spaces/hyphens with underscores, convert to lowercase
+    module_name_base = software_name.replace(" ", "_").replace("-", "_").lower()
+    module_to_run = f"{module_name_base}_prepare"
+
+    log.info(f"Attempting preparation for software: '{software_name}' (Module: '{module_to_run}')")
+
+    try:
+        # Construct the full module path within the package
+        prep_package = "computer_use_ootb_internal.preparation"
+        full_module_path = f"{prep_package}.{module_to_run}"
+
+        # Dynamically import the module
+        # Check if module exists first using pkgutil to avoid import errors
+        # Note: pkgutil.find_loader might be deprecated, consider importlib.util.find_spec
+        loader = pkgutil.find_loader(full_module_path)
+        if loader is None:
+            log.warning(f"Preparation module '{full_module_path}' not found. Skipping preparation.")
+            return
+
+        prep_module = importlib.import_module(full_module_path)
+
+        # Check if the module has the expected function
+        if hasattr(prep_module, "run_preparation") and callable(prep_module.run_preparation):
+            log.info(f"Running preparation function from {full_module_path}...")
+            prep_module.run_preparation(state)
+            log.info(f"Preparation function from {full_module_path} completed.")
+        else:
+            log.warning(f"Module {full_module_path} found, but does not have a callable 'run_preparation' function. Skipping.")
+
+    except ModuleNotFoundError:
+        log.warning(f"Preparation module '{full_module_path}' not found. Skipping preparation.")
+    except Exception as e:
+        log.error(f"Error during dynamic preparation loading/execution for '{module_to_run}': {e}", exc_info=True)
 
 
 @app.post("/update_params")
@@ -177,7 +160,7 @@ async def update_parameters(request: Request):
     
     log_ootb_request(shared_state.server_url, "update_params", data)
 
-    # Call the preparation function here, after parameters are updated
+    # Call the (now dynamic) preparation function here, after parameters are updated
     prepare_environment(shared_state)
 
     return JSONResponse(

computer_use_ootb_internal/guard_service.py

@@ -0,0 +1,436 @@
+# src/computer_use_ootb_internal/guard_service.py
+import sys
+import os
+import time
+import logging
+import subprocess
+import pathlib
+import ctypes
+import requests # For server polling
+import servicemanager # From pywin32
+import win32serviceutil # From pywin32
+import win32service # From pywin32
+import win32event # From pywin32
+import win32api # From pywin32
+import win32process # From pywin32
+import win32security # From pywin32
+import win32profile # From pywin32
+import win32ts # From pywin32 (Terminal Services API)
+import win32con # Added import
+import psutil # For process/user info
+
+# --- Configuration ---
+# Internal service name
+_SERVICE_NAME = "OOTBGuardService"
+# Display name in Windows Services MMC
+_SERVICE_DISPLAY_NAME = "OOTB Guard Service"
+# Description in Windows Services MMC
+_SERVICE_DESCRIPTION = "Background service for OOTB monitoring and remote management."
+# Package name for updates
+_PACKAGE_NAME = "computer-use-ootb-internal"
+# Main module to start/stop for users
+_OOTB_MODULE = "computer_use_ootb_internal.app_teachmode"
+# Server endpoint to poll for commands (replace with your actual URL)
+_SERVER_COMMAND_URL = "http://52.160.105.102:7000/api/guard" # Using HTTP as port was specified
+# How often to poll the server (in seconds)
+_POLLING_INTERVAL = 60
+# Placeholder for a machine identifier or API key for the server
+_MACHINE_ID = "YOUR_MACHINE_ID_OR_API_KEY" # EXAMPLE - Implement actual ID/auth
+# Log file location (consider using Windows Event Log instead for production)
+_LOG_FILE = pathlib.Path(os.environ['PROGRAMDATA']) / "OOTBGuardService" / "guard.log"
+# --- End Configuration ---
+
+# Ensure log directory exists
+_LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+logging.basicConfig(
+    filename=_LOG_FILE,
+    level=logging.INFO,
+    format='%(asctime)s %(levelname)s %(message)s'
+)
+
+def get_python_executable():
+    """Gets the quoted path to the current 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."""
+    python_path = pathlib.Path(sys.executable)
+    pip_path = python_path.parent / "Scripts" / "pip.exe"
+    if pip_path.exists():
+        pip_exe = str(pip_path)
+        if " " in pip_exe and not pip_exe.startswith('"'):
+            pip_exe = f'"{pip_exe}"'
+        return pip_exe
+    else:
+        logging.warning("pip.exe not found in Scripts directory. Falling back to 'python -m pip'.")
+        return f"{get_python_executable()} -m pip"
+
+def log_info(msg):
+    logging.info(msg)
+    try:
+        servicemanager.LogInfoMsg(str(msg)) # Also log to Windows Event Log Application channel
+    except Exception as e:
+        logging.warning(f"Could not write to Windows Event Log: {e}") # Avoid crashing service if event log fails
+
+def log_error(msg, exc_info=False):
+    logging.error(msg, exc_info=exc_info)
+    try:
+        servicemanager.LogErrorMsg(str(msg))
+    except Exception as e:
+        logging.warning(f"Could not write error to Windows Event Log: {e}")
+
+class GuardService(win32serviceutil.ServiceFramework):
+    _svc_name_ = _SERVICE_NAME
+    _svc_display_name_ = _SERVICE_DISPLAY_NAME
+    _svc_description_ = _SERVICE_DESCRIPTION
+
+    def __init__(self, args):
+        win32serviceutil.ServiceFramework.__init__(self, args)
+        self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
+        self.is_running = True
+        self.python_exe = get_python_executable()
+        self.pip_command_base = get_pip_executable()
+        self.ootb_command = f"{self.python_exe} -m {_OOTB_MODULE}"
+        self.session = requests.Session() # Reuse session for polling
+
+    def SvcStop(self):
+        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
+        win32event.SetEvent(self.hWaitStop)
+        self.is_running = False
+        log_info(f"{_SERVICE_NAME} is stopping.")
+
+    def SvcDoRun(self):
+        servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE,
+                              servicemanager.PYS_SERVICE_STARTED,
+                              (self._svc_name_, ''))
+        self.main_loop()
+        # If main_loop exits cleanly (shouldn't happen with while self.is_running)
+        log_info(f"{_SERVICE_NAME} main loop exited.")
+
+
+    def main_loop(self):
+        log_info(f"{_SERVICE_NAME} started. Polling {_SERVER_COMMAND_URL} every {_POLLING_INTERVAL}s.")
+        while self.is_running:
+            try:
+                self.poll_server_for_commands()
+            except Exception as e:
+                log_error(f"Error in main loop polling cycle: {e}", exc_info=True)
+
+            # Wait for stop event or timeout
+            rc = win32event.WaitForSingleObject(self.hWaitStop, _POLLING_INTERVAL * 1000)
+            if rc == win32event.WAIT_OBJECT_0:
+                # Stop event signaled
+                break
+        log_info(f"{_SERVICE_NAME} is shutting down main loop.")
+
+
+    def poll_server_for_commands(self):
+        log_info(f"Polling server for commands...")
+        try:
+            headers = {'Authorization': f'Bearer {_MACHINE_ID}'} # Example auth
+            # Add machine identifier if needed by server
+            params = {'machine_id': os.getenv('COMPUTERNAME', 'unknown')}
+            response = self.session.get(_SERVER_COMMAND_URL, headers=headers, params=params, timeout=30)
+            response.raise_for_status() # Raise exception for bad status codes
+
+            commands = response.json() # Expecting a list of command objects
+            if not commands:
+                # log_info("No commands received.") # Reduce log noise
+                return
+
+            log_info(f"Received {len(commands)} command(s). Processing...")
+            for command in commands:
+                action = command.get("action")
+                target = command.get("target_user", "all_active") # Default to all
+                command_id = command.get("command_id", "N/A") # Optional: for reporting status
+
+                log_info(f"Processing Command ID {command_id}: action='{action}', target='{target}'")
+                status = "failed" # Default status
+                try:
+                    if action == "update":
+                        status = self.handle_update()
+                    elif action == "stop_ootb":
+                        status = self.handle_stop(target)
+                    elif action == "start_ootb":
+                        status = self.handle_start(target)
+                    else:
+                        log_error(f"Unknown action received: {action}")
+                        status = "unknown_action"
+                except Exception as handler_ex:
+                     log_error(f"Error executing action '{action}' for command {command_id}: {handler_ex}", exc_info=True)
+                     status = "execution_error"
+
+                # TODO: Add mechanism to report command completion/failure back to server
+                # Example: self.report_command_status(command_id, status)
+                log_info(f"Finished processing Command ID {command_id}: Status='{status}'")
+
+        except requests.exceptions.RequestException as e:
+            log_error(f"Failed to poll server: {e}")
+        except Exception as e:
+            log_error(f"Error processing server commands: {e}", exc_info=True)
+
+
+    def handle_update(self):
+        log_info("Executing OOTB update...")
+        if not self.pip_command_base:
+            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}")
+        try:
+            # Run update command
+            result = subprocess.run(update_command, shell=True, capture_output=True, text=True, check=True, timeout=300)
+            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}")
+            return f"failed_exit_{e.returncode}"
+        except subprocess.TimeoutExpired:
+             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)
+            return "failed_exception"
+
+
+    def _get_ootb_processes(self, target_user="all_active"):
+        """Finds OOTB processes, optionally filtering by username."""
+        ootb_procs = []
+        target_pid_list = []
+        try:
+            # Get a list of usernames we are interested in
+            target_users = set()
+            if target_user == "all_active":
+                 for user_session in psutil.users():
+                      # Normalize username (remove domain if present)
+                      username = user_session.name.split('\\')[-1]
+                      target_users.add(username.lower())
+            else:
+                 target_users.add(target_user.lower())
+
+            log_info(f"Searching for OOTB processes for users: {target_users}")
+
+            for proc in psutil.process_iter(['pid', 'name', 'username', 'cmdline']):
+                try:
+                    pinfo = proc.info
+                    # Normalize process username
+                    proc_username = pinfo['username']
+                    if proc_username:
+                        proc_username = proc_username.split('\\')[-1].lower()
+
+                    # Check if process user is one of the targets
+                    if proc_username in target_users:
+                        # Check if command line matches our OOTB app pattern
+                        cmdline = ' '.join(pinfo['cmdline']) if pinfo['cmdline'] else ''
+                        # Simple check: does it contain python executable and the module name?
+                        if (self.python_exe.strip('"') in cmdline) and (_OOTB_MODULE in cmdline):
+                            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 # Process might have died or we lack permissions
+            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)
+        return ootb_procs
+
+
+    def handle_stop(self, target_user="all_active"):
+        log_info(f"Executing stop OOTB for target '{target_user}'...")
+        stopped_count = 0
+        procs_to_stop = self._get_ootb_processes(target_user)
+
+        if not procs_to_stop:
+            log_info("No running OOTB processes found for target.")
+            return "no_process_found"
+
+        for proc in procs_to_stop:
+            try:
+                username = proc.info.get('username', 'unknown_user')
+                log_info(f"Terminating process PID={proc.pid}, User={username}")
+                proc.terminate() # Ask nicely first
+                try:
+                    proc.wait(timeout=3) # Wait a bit
+                    log_info(f"Process PID={proc.pid} terminated successfully.")
+                    stopped_count += 1
+                except psutil.TimeoutExpired:
+                    log_warning(f"Process PID={proc.pid} did not terminate gracefully, killing.")
+                    proc.kill()
+                    stopped_count += 1
+            except psutil.NoSuchProcess:
+                 log_info(f"Process PID={proc.pid} already terminated.")
+                 stopped_count +=1 # Count it if it disappeared
+            except psutil.AccessDenied:
+                log_error(f"Access denied trying to terminate process PID={proc.pid}. Service might lack privileges?")
+            except Exception as e:
+                log_error(f"Error stopping process PID={proc.pid}: {e}", exc_info=True)
+
+        log_info(f"Finished stopping OOTB. Terminated {stopped_count} process(es).")
+        return f"success_stopped_{stopped_count}"
+
+
+    def handle_start(self, target_user="all_active"):
+        log_info(f"Executing start OOTB for target '{target_user}'...")
+        started_count = 0
+        target_users_started = set()
+        users_failed_to_start = set()
+
+        try:
+            sessions = win32ts.WTSEnumerateSessions(win32ts.WTS_CURRENT_SERVER_HANDLE)
+            active_sessions = {} # Store user: session_id for active sessions
+
+            for session in sessions:
+                 # Look for Active sessions, potentially disconnected ones too?
+                 # For now, only WTSActive
+                 if session['State'] == win32ts.WTSActive:
+                    try:
+                         user = win32ts.WTSQuerySessionInformation(win32ts.WTS_CURRENT_SERVER_HANDLE, session['SessionId'], win32ts.WTSUserName)
+                         if user: # Filter out system sessions etc.
+                              normalized_user = user.lower()
+                              active_sessions[normalized_user] = session['SessionId']
+                    except Exception as query_err:
+                         log_warning(f"Could not query session {session['SessionId']}: {query_err}")
+
+            log_info(f"Found active user sessions: {active_sessions}")
+
+            target_session_map = {} # user:session_id
+            if target_user == "all_active":
+                 target_session_map = active_sessions
+            else:
+                normalized_target = target_user.lower()
+                if normalized_target in active_sessions:
+                     target_session_map[normalized_target] = active_sessions[normalized_target]
+                else:
+                     log_warning(f"Target user '{target_user}' not found in active sessions.")
+                     return "failed_user_not_active"
+
+            if not target_session_map:
+                 log_info("No target user sessions found to start OOTB in.")
+                 return "failed_no_target_sessions"
+
+            # Check if OOTB is already running for the target users
+            running_procs = self._get_ootb_processes(target_user)
+            users_already_running = set()
+            for proc in running_procs:
+                try:
+                     proc_username = proc.info.get('username')
+                     if proc_username:
+                          users_already_running.add(proc_username.split('\\')[-1].lower())
+                except Exception:
+                     pass # Ignore errors getting username here
+
+            log_info(f"Users already running OOTB: {users_already_running}")
+
+            for user, session_id in target_session_map.items():
+                 token = None # Ensure token is reset/defined
+                 try:
+                     if user in users_already_running:
+                         log_info(f"OOTB already seems to be running for user '{user}'. Skipping start.")
+                         continue
+
+                     log_info(f"Attempting to start OOTB for user '{user}' in session {session_id}...")
+
+                     # Get user token
+                     token = win32ts.WTSQueryUserToken(session_id)
+
+                     # Create environment block for the user
+                     env = win32profile.CreateEnvironmentBlock(token, False)
+
+                     # Create startup info
+                     startup = win32process.STARTUPINFO()
+                     startup.dwFlags = win32process.STARTF_USESHOWWINDOW
+                     # Attempt to show window on user's desktop
+                     # Requires Service to have "Allow service to interact with desktop" checked
+                     # AND Interactive Services Detection service running (often disabled now).
+                     # May be better to run hidden (SW_HIDE) or default.
+                     startup.wShowWindow = win32con.SW_SHOW
+                     startup.lpDesktop = 'winsta0\\default' # Try targeting default interactive desktop
+
+                     # Create process as user
+                     # Needs SeAssignPrimaryTokenPrivilege, SeIncreaseQuotaPrivilege for service account.
+                     creation_flags = win32process.CREATE_NEW_CONSOLE | win32process.CREATE_UNICODE_ENVIRONMENT
+
+                     hProcess, hThread, dwPid, dwTid = win32process.CreateProcessAsUser(
+                         token,              # User token
+                         self.python_exe,    # Application name (python executable)
+                         self.ootb_command,  # Command line
+                         None,               # Process attributes
+                         None,               # Thread attributes
+                         False,              # Inherit handles
+                         creation_flags,     # Creation flags
+                         env,                # Environment
+                         None,               # Current directory (use default)
+                         startup             # Startup info
+                     )
+                     log_info(f"Successfully started OOTB for user '{user}' (PID: {dwPid}).")
+                     started_count += 1
+                     target_users_started.add(user)
+                     # Close handles immediately
+                     win32api.CloseHandle(hProcess)
+                     win32api.CloseHandle(hThread)
+
+                 except Exception as proc_err:
+                      log_error(f"Failed to start OOTB for user '{user}' in session {session_id}: {proc_err}", exc_info=True)
+                      users_failed_to_start.add(user)
+                 finally:
+                      # Ensure token handle is always closed if obtained
+                      if token:
+                           try: win32api.CloseHandle(token)
+                           except: pass
+
+
+            log_info(f"Finished starting OOTB. Started {started_count} new instance(s). Failed for users: {users_failed_to_start or 'None'}")
+            if users_failed_to_start:
+                 return f"partial_success_started_{started_count}_failed_for_{len(users_failed_to_start)}"
+            elif started_count > 0:
+                 return f"success_started_{started_count}"
+            else:
+                 return "no_action_needed_already_running"
+
+        except Exception as e:
+             log_error(f"Error during start OOTB process: {e}", exc_info=True)
+             return "failed_exception"
+
+
+# This block is essential for the service framework to handle
+# command-line arguments like 'install', 'start', 'stop', 'remove', 'debug'.
+if __name__ == '__main__':
+    # Add logic to allow debugging from command line easily
+    if len(sys.argv) > 1 and sys.argv[1] == 'debug':
+        log_info("Starting service in debug mode...")
+        service_instance = GuardService(sys.argv)
+        service_instance.is_running = True # Ensure loop runs
+        try:
+            # Run the main loop directly for debugging
+            service_instance.main_loop()
+            # Simulate stop signal for clean exit in debug
+            # service_instance.SvcStop() # Or let it run until Ctrl+C?
+        except KeyboardInterrupt:
+            log_info("Debug mode interrupted by user.")
+            service_instance.SvcStop() # Attempt clean stop
+        log_info("Debug mode finished.")
+    elif len(sys.argv) == 1:
+        # Called without arguments, run as a service instance via SCM
+        try:
+            servicemanager.Initialize()
+            servicemanager.PrepareToHostSingle(GuardService)
+            servicemanager.StartServiceCtrlDispatcher()
+        except win32service.error as details:
+            import winerror
+            if details.winerror == winerror.ERROR_FAILED_SERVICE_CONTROLLER_CONNECT:
+                print(f"Error: Cannot connect to Service Control Manager.")
+                print(f"Use 'python {os.path.basename(__file__)} install|start|stop|remove|debug'")
+            else:
+                print(f"Error preparing service: {details}")
+        except Exception as e:
+             print(f"Unexpected error initializing service: {e}")
+
+    else:
+         # Called with install/start/stop/remove args, let ServiceFramework handle them
+        win32serviceutil.HandleCommandLine(GuardService) 

computer_use_ootb_internal/preparation/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'preparation' directory a Python package 

computer_use_ootb_internal/preparation/star_rail_prepare.py

@@ -0,0 +1,65 @@
+# src/computer_use_ootb_internal/preparation/star_rail_prepare.py
+import time
+import platform
+import pyautogui
+import webbrowser
+import logging # Use logging instead of print for better practice
+
+# Set up logging for this module if needed, or rely on root logger
+log = logging.getLogger(__name__)
+
+def run_preparation(state):
+    """
+    Performs environment preparation specific to Star Rail on Windows.
+    Opens the specified URL in Edge and performs initial clicks.
+    """
+    if platform.system() != "Windows":
+        log.info("Star Rail preparation skipped: Not running on Windows.")
+        return
+
+    log.info("Star Rail preparation: Starting environment setup on Windows...")
+    url = "https://sr.mihoyo.com/cloud/#/" # Consider making this configurable later
+    browser_opened = False
+    try:
+        # Use only webbrowser.open
+        log.info(f"Attempting to open {url} using webbrowser.open()...")
+        if webbrowser.open(url):
+            log.info(f"Successfully requested browser to open {url} via webbrowser.open().")
+            browser_opened = True
+        else:
+            log.warning("webbrowser.open() returned False, indicating potential failure.")
+
+        if not browser_opened:
+            log.error("Failed to confirm browser opening via webbrowser.open(). Will still attempt clicks.")
+
+        # Add pyautogui click after attempting to open the browser
+        log.info("Proceeding with pyautogui actions...")
+        time.sleep(5) # Wait time for the browser to load
+
+        # Get screen size
+        screen_width, screen_height = pyautogui.size()
+        log.info(f"Detected screen size: {screen_width}x{screen_height}")
+
+        # Calculate click coordinates based on a reference resolution (e.g., 1280x720)
+        # TODO: Make these coordinates more robust or configurable
+        click_x = int(screen_width * (1036 / 1280))
+        click_y = int(screen_height * (500 / 720))
+        log.info(f"Calculated click coordinates: ({click_x}, {click_y})")
+
+        # Disable failsafe before clicking
+        pyautogui.FAILSAFE = False
+        log.info("PyAutoGUI failsafe temporarily disabled.")
+
+        log.info(f"Clicking at coordinates: ({click_x}, {click_y})")
+        pyautogui.click(click_x, click_y)
+        time.sleep(2)
+        pyautogui.click(click_x, click_y) # Double click?
+
+        log.info("Star Rail preparation clicks completed.")
+
+    except Exception as e:
+        log.error(f"Error during Star Rail preparation (browser/click): {e}", exc_info=True)
+    finally:
+         # Ensure failsafe is re-enabled
+         pyautogui.FAILSAFE = True
+         log.info("PyAutoGUI failsafe re-enabled.") 

computer_use_ootb_internal/service_manager.py

@@ -0,0 +1,142 @@
+# src/computer_use_ootb_internal/service_manager.py
+import sys
+import os
+import inspect
+import subprocess
+import ctypes
+import platform
+import time
+
+# Constants need to match guard_service.py
+_SERVICE_NAME = "OOTBGuardService"
+_SERVICE_DISPLAY_NAME = "OOTB Guard Service"
+
+def is_admin():
+    """Check if the script is running with administrative privileges."""
+    if platform.system() != "Windows":
+        return False # Only applicable on Windows
+    try:
+        return ctypes.windll.shell32.IsUserAnAdmin()
+    except:
+        return False
+
+def get_service_module_path():
+    """Gets the absolute path to the guard_service.py module."""
+    # Find the path relative to this script's location
+    # This assumes service_manager.py and guard_service.py are in the same installed package directory
+    try:
+        current_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
+        service_module = os.path.join(current_dir, "guard_service.py")
+        if not os.path.exists(service_module):
+            raise FileNotFoundError(f"guard_service.py not found adjacent to service_manager.py in {current_dir}")
+        return service_module
+    except Exception as e:
+         # Fallback if inspect fails (e.g., in some frozen environments)
+         # Try finding it relative to the script itself? Unreliable.
+         # Let's try sys.prefix - might work in standard venv/conda installs
+         try:
+             # sys.prefix points to the environment root (e.g., C:\path\to\env)
+             # Package likely installed in Lib\site-packages\<package_name>
+             # This depends heavily on installation layout
+             package_name = __name__.split('.')[0] # Should be 'computer_use_ootb_internal'
+             site_packages_path = os.path.join(sys.prefix, 'Lib', 'site-packages')
+             module_dir = os.path.join(site_packages_path, package_name)
+             service_module = os.path.join(module_dir, "guard_service.py")
+             if os.path.exists(service_module):
+                 print(f"Warning: Found service module via sys.prefix fallback: {service_module}")
+                 return service_module
+             else:
+                 raise FileNotFoundError(f"guard_service.py not found via inspect or sys.prefix fallback (checked {module_dir})")
+         except Exception as fallback_e:
+             raise FileNotFoundError(f"Could not find guard_service.py using inspect ({e}) or sys.prefix ({fallback_e}). Check installation.")
+
+
+def run_service_command(command_args, check_errors=True):
+    """Runs the guard_service.py script with specified command-line args."""
+    if not is_admin():
+        print("Error: Administrative privileges are required to manage the service.", file=sys.stderr)
+        print("Please run this command from an Administrator Command Prompt or PowerShell.", file=sys.stderr)
+        return False
+
+    try:
+        python_exe = sys.executable # Use the same python that's running this script
+        service_script = get_service_module_path()
+    except FileNotFoundError as e:
+         print(f"Error: {e}", file=sys.stderr)
+         return False
+
+    # Quote paths if they contain spaces
+    if " " in python_exe and not python_exe.startswith('"'):
+        python_exe = f'"{python_exe}"'
+    if " " in service_script and not service_script.startswith('"'):
+        service_script = f'"{service_script}"'
+
+    # Construct command using list to avoid shell quoting issues
+    cmd = [sys.executable, get_service_module_path()] + command_args
+    print(f"Executing command: {' '.join(cmd)}")
+
+    try:
+        # Run the command. Use shell=False with list of args.
+        # Capture output to check for specific errors if needed, but print it too.
+        result = subprocess.run(cmd, capture_output=True, text=True, check=check_errors, encoding='utf-8')
+        if result.stdout:
+            print("Command STDOUT:")
+            print(result.stdout)
+        if result.stderr:
+            print("Command STDERR:")
+            print(result.stderr)
+        print(f"Command {' '.join(command_args)} executed successfully.")
+        return True
+    except FileNotFoundError as e:
+         print(f"Error: Could not find Python executable or service script during execution.", file=sys.stderr)
+         print(f" Details: {e}", file=sys.stderr)
+         return False
+    except subprocess.CalledProcessError as e:
+        print(f"Error executing service command {' '.join(command_args)} (Exit Code {e.returncode}).", file=sys.stderr)
+        if e.stdout:
+            print("Subprocess STDOUT:")
+            print(e.stdout)
+        if e.stderr:
+            print("Subprocess STDERR:")
+            print(e.stderr)
+        return False
+    except Exception as e:
+        print(f"An unexpected error occurred running service command: {e}", file=sys.stderr)
+        return False
+
+
+def install_and_start():
+    """Installs and starts the Guard Service."""
+    print(f"Attempting to install/update service: '{_SERVICE_NAME}' ('{_SERVICE_DISPLAY_NAME}')")
+    # Use 'update' which handles install or updates display name/path if needed
+    if run_service_command(['--startup', 'auto', 'update']): # Set startup to auto, then update
+        print(f"\nAttempting to start service: '{_SERVICE_NAME}' (waiting a few seconds first)")
+        time.sleep(3) # Give SCM time to register the update
+        if run_service_command(['start']):
+            print(f"\nService '{_SERVICE_NAME}' installed/updated and started successfully.")
+        else:
+             print(f"\nWarning: Service '{_SERVICE_NAME}' installed/updated but failed to start.", file=sys.stderr)
+             print(f" Check service logs ('C:\ProgramData\OOTBGuardService\guard.log') or Windows Event Viewer for details.", file=sys.stderr)
+             print(f" You may need to start it manually via 'services.msc' or `net start {_SERVICE_NAME}`.")
+    else:
+        print(f"\nService '{_SERVICE_NAME}' installation/update failed.", file=sys.stderr)
+
+
+def stop_and_remove():
+    """Stops and removes the Guard Service."""
+    print(f"Attempting to stop service: '{_SERVICE_NAME}' (will ignore errors if not running)")
+    # Run stop first, ignore errors (check_errors=False)
+    run_service_command(['stop'], check_errors=False)
+    time.sleep(2) # Give service time to stop
+
+    print(f"\nAttempting to remove service: '{_SERVICE_NAME}'")
+    if run_service_command(['remove']):
+        print(f"\nService '{_SERVICE_NAME}' stopped (if running) and removed successfully.")
+    else:
+        print(f"\nService '{_SERVICE_NAME}' removal failed.", file=sys.stderr)
+        print(f" Ensure the service was stopped first, or check permissions.", file=sys.stderr)
+
+if __name__ == '__main__':
+     # Allow calling functions directly for testing if needed
+     print("This script provides service management commands.")
+     print("Use 'ootb-install-service' or 'ootb-remove-service' as Administrator.") 

{computer_use_ootb_internal-0.0.110.dist-info → computer_use_ootb_internal-0.0.112.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: computer-use-ootb-internal
-Version: 0.0.110
+Version: 0.0.112
 Summary: Computer Use OOTB
 Author-email: Siyuan Hu <siyuan.hu.sg@gmail.com>
 Requires-Python: >=3.11
@@ -12,17 +12,17 @@ Requires-Dist: jsonschema==4.22.0
 Requires-Dist: litellm
 Requires-Dist: matplotlib
 Requires-Dist: opencv-python
-Requires-Dist: pre-commit==3.8.0
+Requires-Dist: psutil>=5.0; sys_platform == 'win32'
 Requires-Dist: pyautogui==0.9.54
-Requires-Dist: pytest-asyncio==0.23.6
-Requires-Dist: pytest==8.3.3
+Requires-Dist: pywin32>=306; sys_platform == 'win32'
 Requires-Dist: pywinauto; sys_platform == 'win32'
-Requires-Dist: ruff==0.6.7
+Requires-Dist: requests>=2.0
 Requires-Dist: screeninfo
 Requires-Dist: streamlit>=1.38.0
 Requires-Dist: textdistance
 Requires-Dist: uiautomation; sys_platform == 'win32'
 Provides-Extra: dev
+Requires-Dist: pre-commit>=3.8.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23.6; extra == 'dev'
 Requires-Dist: pytest>=8.3.3; extra == 'dev'
 Requires-Dist: ruff>=0.6.7; extra == 'dev'

{computer_use_ootb_internal-0.0.110.dist-info → computer_use_ootb_internal-0.0.112.dist-info}/RECORD

@@ -1,11 +1,12 @@
 computer_use_ootb_internal/README.md,sha256=FxpW95lyub2iX73ZDfK6ML7SdEKg060H5I6Grub7li4,31
 computer_use_ootb_internal/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-computer_use_ootb_internal/app_teachmode.py,sha256=-PQVCIi-6mkJ8vbyEenTPnCDYgu7R33ci_kFY7Ccfbw,18771
+computer_use_ootb_internal/app_teachmode.py,sha256=U0vHAEHeDMDioYatLQkzesT1Hy0aI6kKjhAlV86zxfc,17902
 computer_use_ootb_internal/app_teachmode_gradio.py,sha256=cmFpBrkdlZxOQADWveVdIaaNqaBD8IVs-xNLJogU7F8,7909
 computer_use_ootb_internal/dependency_check.py,sha256=y8RMEP6RXQzTgU1MS_1piBLtz4J-Hfn9RjUZg59dyvo,1333
+computer_use_ootb_internal/guard_service.py,sha256=bTzBQMnHYaUXBwCWcnn0cXBPJyKl26-LVRIRB-fiRzo,20558
 computer_use_ootb_internal/requirements-lite.txt,sha256=5DAHomz4A_P2BmTIXNkNqkHbnIF0AyZ4_1XAlb1LaYs,290
 computer_use_ootb_internal/run_teachmode_ootb_args.py,sha256=7Dj0iY4GG7P03tRKYJ2x9Yvt-PE-b7uyjCAed3SaF3Y,7086
-computer_use_ootb_internal/startup_utils.py,sha256=JXu_13YuVdCUVJHgLoSyQV-tHy7qGEYgyPOyVgoxva4,9334
+computer_use_ootb_internal/service_manager.py,sha256=sesbSUBBqm6W77Dykaw-HGARU-yNdK9DqOHPiR2TbkE,6920
 computer_use_ootb_internal/computer_use_demo/animation/click_animation.py,sha256=tP1gsayFy-CKk10UlrE9RlexwlHWiHQUe5Ogg4vQvSg,3234
 computer_use_ootb_internal/computer_use_demo/animation/icons8-select-cursor-transparent-96.gif,sha256=4LfwsfFQnREXrNRs32aJU2jO65JXianJoL_8q7-8elg,30966
 computer_use_ootb_internal/computer_use_demo/animation/test_animation.py,sha256=2R1u98OLKYalSZ5nt5vvyZ71FL5R5vLv-n8zM8jVdV8,1183
@@ -31,7 +32,9 @@ computer_use_ootb_internal/computer_use_demo/tools/computer_marbot.py,sha256=zZu
 computer_use_ootb_internal/computer_use_demo/tools/edit.py,sha256=b0PwUitxckHCQqFP3ZwlthWdqNkn7WETeTHeB6-o98c,11486
 computer_use_ootb_internal/computer_use_demo/tools/run.py,sha256=xhXdnBK1di9muaO44CEirL9hpGy3NmKbjfMpyeVmn8Y,1595
 computer_use_ootb_internal/computer_use_demo/tools/screen_capture.py,sha256=L8qfvtUkPPQGt92N-2Zfw5ZTDBzLsDps39uMnX3_uSA,6857
-computer_use_ootb_internal-0.0.110.dist-info/METADATA,sha256=VApESAleeSZz-CoNCaWHkEC9WFHl-Nb5qfa6MUC3bIw,937
-computer_use_ootb_internal-0.0.110.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-computer_use_ootb_internal-0.0.110.dist-info/entry_points.txt,sha256=XOxhaseEddM9LaMoWFupcavxn5jMU7kMrLyrmcfc_bQ,255
-computer_use_ootb_internal-0.0.110.dist-info/RECORD,,
+computer_use_ootb_internal/preparation/__init__.py,sha256=AgtGHcBpiTkxJjF0xwcs3yyQ6SyUvhL3G0vD2XO-zJw,63
+computer_use_ootb_internal/preparation/star_rail_prepare.py,sha256=s1VWszcTnJAKxqCHFlaOEwPkqVSrkiFx_yKpWSnSbHs,2649
+computer_use_ootb_internal-0.0.112.dist-info/METADATA,sha256=P4zVajg7g2i1wpHYk98DU4M9JawiqWp4mKz7crW9qSM,993
+computer_use_ootb_internal-0.0.112.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+computer_use_ootb_internal-0.0.112.dist-info/entry_points.txt,sha256=bXfyAU_qq-G1EiEgAQEioXvgEdRCFxaTooqdDD9Y4OA,258
+computer_use_ootb_internal-0.0.112.dist-info/RECORD,,

computer_use_ootb_internal-0.0.112.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+computer-use-ootb-internal = computer_use_ootb_internal.app_teachmode:main
+ootb-install-service = computer_use_ootb_internal.service_manager:install_and_start
+ootb-remove-service = computer_use_ootb_internal.service_manager:stop_and_remove

computer_use_ootb_internal/startup_utils.py

@@ -1,194 +0,0 @@
-import sys
-import os
-import winreg
-import ctypes
-import platform
-import shutil
-import subprocess
-import pathlib
-
-REG_PATH = r"Software\Microsoft\Windows\CurrentVersion\Run"
-APP_NAME = "OOTBLite"  # Or a more specific name for your app's startup entry
-# The package name as installed by pip
-PACKAGE_NAME = "computer-use-ootb-internal"
-# The main module to run at startup
-STARTUP_MODULE = "computer_use_ootb_internal.app_teachmode"
-# Name for the scheduled task
-TASK_NAME = "OOTBLite_AutoUpdate"
-
-def is_admin():
-    """Check if the script is running with administrative privileges."""
-    try:
-        return ctypes.windll.shell32.IsUserAnAdmin()
-    except:
-        return False
-
-def get_python_executable():
-    """Gets the quoted path to the current 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."""
-    python_path = pathlib.Path(sys.executable)
-    # Common location is ../Scripts/pip.exe relative to python.exe
-    pip_path = python_path.parent / "Scripts" / "pip.exe"
-    if pip_path.exists():
-         # 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:
-        # Fallback: try using 'python -m pip'
-        print("Warning: pip.exe not found in Scripts directory. Falling back to 'python -m pip'.", file=sys.stderr)
-        return f"{get_python_executable()} -m pip"
-
-def run_powershell_command(command):
-    """Executes a PowerShell command and handles output/errors."""
-    try:
-        # Use powershell.exe - it's more universally available than pwsh.exe
-        # capture_output=True suppresses output unless there's an error
-        # text=True decodes output/error streams
-        # check=True raises CalledProcessError on non-zero exit codes
-        result = subprocess.run(
-            ["powershell.exe", "-NoProfile", "-Command", command],
-            capture_output=True, text=True, check=True, encoding='utf-8'
-        )
-        print(f"PowerShell command executed successfully.")
-        if result.stdout:
-            print("Output:\n", result.stdout)
-        return True
-    except FileNotFoundError:
-        print("Error: 'powershell.exe' not found. Cannot manage scheduled tasks.", file=sys.stderr)
-        return False
-    except subprocess.CalledProcessError as e:
-        print(f"Error executing PowerShell command:", file=sys.stderr)
-        print(f"  Command: {e.cmd}", file=sys.stderr)
-        print(f"  Exit Code: {e.returncode}", file=sys.stderr)
-        print(f"  Stderr: {e.stderr}", file=sys.stderr)
-        print(f"  Stdout: {e.stdout}", file=sys.stderr)
-        return False
-    except Exception as e:
-        print(f"An unexpected error occurred running PowerShell: {e}", file=sys.stderr)
-        return False
-
-
-def configure_startup():
-    """Adds the application to Windows startup and sets up auto-update task."""
-    if platform.system() != "Windows":
-        print("Error: This utility is only for Windows.", file=sys.stderr)
-        sys.exit(1)
-
-    if not is_admin():
-        print("Error: This utility requires administrative privileges.", file=sys.stderr)
-        print("Please run this command from an Administrator Command Prompt or PowerShell.", file=sys.stderr)
-        sys.exit(1)
-
-    # 1. Configure Registry for Startup
-    print("Configuring registry for application startup...")
-    python_exe = get_python_executable()
-    startup_command = f'{python_exe} -m {STARTUP_MODULE}'
-    try:
-        key = winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE, REG_PATH)
-        winreg.SetValueEx(key, APP_NAME, 0, winreg.REG_SZ, startup_command)
-        winreg.CloseKey(key)
-        print(f"Success: Registry key HKLM\{REG_PATH}\{APP_NAME} set.")
-        print(f"  Command: {startup_command}")
-    except OSError as e:
-        print(f"Error: Failed to set registry key HKLM\{REG_PATH}\{APP_NAME}", file=sys.stderr)
-        print(f"Details: {e}", file=sys.stderr)
-        # Continue to task setup even if registry fails? Or exit? Let's exit for now.
-        sys.exit(1)
-    except Exception as e:
-        print(f"An unexpected error occurred setting registry key: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    # 2. Configure Scheduled Task for Auto-Update
-    print("\nConfiguring scheduled task for automatic updates...")
-    pip_command = get_pip_executable()
-    if not pip_command:
-         print("Error: Could not determine pip command. Skipping scheduled task setup.", file=sys.stderr)
-         sys.exit(1) # Exit if we can't find pip
-
-    update_command_args = f'install --upgrade --no-cache-dir {PACKAGE_NAME}'
-    # Need to handle quoting args for PowerShell if pip_command includes python.exe
-    pip_exe_path = pip_command.split()[0]
-    if "-m pip" in pip_command:
-         ps_args = f"-m pip {update_command_args}"
-    else:
-         ps_args = update_command_args
-
-    # PowerShell commands to create the task
-    # Define Action, Trigger, Principal, Settings, and then Register
-    # Note: Escaping quotes for PowerShell within Python string
-    # Ensure executable path and arguments are properly quoted for PowerShell
-    # Use triple-double quotes for f-strings containing single-quoted PowerShell strings
-    action = f"""$Action = New-ScheduledTaskAction -Execute '{pip_exe_path}' -Argument '{ps_args.replace("'", "''")}'""" # Escape single quotes in args for PS string
-    # Trigger: Daily, repeat every hour indefinitely
-    trigger = f"""$Trigger = New-ScheduledTaskTrigger -Daily -At 3am; $Trigger.Repetition.Interval = 'PT1H'; $Trigger.Repetition.Duration = 'P10675199D'""" # Using large duration for 'indefinitely'
-    # Principal: Run as SYSTEM user
-    principal = f"""$Principal = New-ScheduledTaskPrincipal -UserId 'SYSTEM' -LogonType ServiceAccount -RunLevel Highest"""
-    # Settings: Allow start if on batteries, don't stop if goes off batteries (adjust as needed)
-    settings = f"""$Settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable""" # Added StartWhenAvailable
-
-    # Register Task: Use -Force to overwrite if it exists
-    description = f"Hourly check for {PACKAGE_NAME} updates."
-    # Escape single quotes in description just in case PACKAGE_NAME contains them
-    escaped_description = description.replace("'", "''")
-    register_command = f"""{action}; {trigger}; {principal}; {settings}; Register-ScheduledTask -TaskName '{TASK_NAME}' -Action $Action -Trigger $Trigger -Principal $Principal -Settings $Settings -Force -Description '{escaped_description}'"""
-
-    print(f"Attempting to create/update scheduled task '{TASK_NAME}'...")
-    if run_powershell_command(register_command):
-        print(f"Success: Scheduled task '{TASK_NAME}' created/updated.")
-        print(f"  Task Action: {pip_exe_path} {ps_args}")
-    else:
-        print(f"Error: Failed to configure scheduled task '{TASK_NAME}'. Please check PowerShell errors above.", file=sys.stderr)
-        # Decide if failure here is critical
-        # sys.exit(1)
-
-
-def remove_startup():
-    """Removes the application from Windows startup and removes auto-update task."""
-    if platform.system() != "Windows":
-        print("Error: This utility is only for Windows.", file=sys.stderr)
-        sys.exit(1)
-
-    if not is_admin():
-        print("Error: This utility requires administrative privileges.", file=sys.stderr)
-        print("Please run this command from an Administrator Command Prompt or PowerShell.", file=sys.stderr)
-        sys.exit(1)
-
-    # 1. Remove Registry Key
-    print("Removing registry key...")
-    try:
-        key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, REG_PATH, 0, winreg.KEY_WRITE)
-        winreg.DeleteValue(key, APP_NAME)
-        winreg.CloseKey(key)
-        print(f"Success: Registry key HKLM\{REG_PATH}\{APP_NAME} removed.")
-    except FileNotFoundError:
-        print(f"Info: Registry key HKLM\{REG_PATH}\{APP_NAME} not found. No action taken.")
-    except OSError as e:
-        print(f"Error: Failed to delete registry key HKLM\{REG_PATH}\{APP_NAME}", file=sys.stderr)
-        print(f"Details: {e}", file=sys.stderr)
-        # Continue to task removal
-    except Exception as e:
-        print(f"An unexpected error occurred removing registry key: {e}", file=sys.stderr)
-        # Continue to task removal
-
-    # 2. Remove Scheduled Task
-    print(f"\nRemoving scheduled task '{TASK_NAME}'...")
-    # Use -ErrorAction SilentlyContinue for Unregister-ScheduledTask if it might not exist
-    # Use triple-double quotes for f-string
-    unregister_command = f"""Unregister-ScheduledTask -TaskName '{TASK_NAME}' -Confirm:$false -ErrorAction SilentlyContinue"""
-
-    if run_powershell_command(unregister_command):
-        print(f"Success: Scheduled task '{TASK_NAME}' removed (if it existed).")
-    else:
-        print(f"Error: Failed to remove scheduled task '{TASK_NAME}'. Please check PowerShell errors above.", file=sys.stderr)
-
-if __name__ == '__main__':
-    print("This script provides startup and auto-update configuration utilities.")
-    print("Use 'ootb-configure-startup' or 'ootb-remove-startup' as Administrator after installation.") 

computer_use_ootb_internal-0.0.110.dist-info/entry_points.txt

@@ -1,4 +0,0 @@
-[console_scripts]
-computer-use-ootb-internal = computer_use_ootb_internal.app_teachmode:main
-ootb-configure-startup = computer_use_ootb_internal.startup_utils:configure_startup
-ootb-remove-startup = computer_use_ootb_internal.startup_utils:remove_startup