computer-use-ootb-internal 0.0.182__tar.gz → 0.0.184__tar.gz

{computer_use_ootb_internal-0.0.182 → computer_use_ootb_internal-0.0.184}/PKG-INFO

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

{computer_use_ootb_internal-0.0.182 → computer_use_ootb_internal-0.0.184}/pyproject.toml

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

{computer_use_ootb_internal-0.0.182 → computer_use_ootb_internal-0.0.184}/src/computer_use_ootb_internal/guard_service.py

@@ -822,39 +822,47 @@ class GuardService(win32serviceutil.ServiceFramework):
              self.log_error(f"Cannot create task for {username}: sys.executable is not found.")
              return False
         
-        # Use the python executable that the service itself is running under
-        python_exe = sys.executable
-        if ' ' in python_exe and not python_exe.startswith('"'):
-             python_exe = f'"{python_exe}"'
+        # Find the correct python.exe/pythonw.exe from the environment
+        python_exe = self._get_python_executable_from_target_exe()
+        if not python_exe:
+            self.log_error(f"Cannot create task for {username}: Failed to find associated python executable via _get_python_executable_from_target_exe.")
+            return False
 
-        task_name = f"OOTB_UserConnect_{username}"
-        # Action: Run python.exe with the signal script and username argument
-        action_executable = python_exe
+        # Prepare paths and arguments carefully for PowerShell
+        action_executable_path = python_exe.strip("'\"") # Remove potential existing quotes
+        script_path = self.signal_script_path.strip("'\"")
+        user_arg = username # Assuming username has no special chars needing escape within PS
+        
         # Ensure script path is quoted if needed
-        script_arg = self.signal_script_path # Should be quoted already by _find_signal_script
+        quoted_script_path = f'""{script_path}""' if ' ' in script_path else script_path # Use "" for literal quotes inside PS string
         # 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
+        # Construct the argument string passed TO python.exe: "script_path" username
+        python_arguments = f'{quoted_script_path} {user_arg}'
         
         # Working directory for the script (likely its own directory)
         try:
-            script_dir = os.path.dirname(self.signal_script_path.strip('"'))
+            script_dir = os.path.dirname(script_path)
             if not script_dir: script_dir = "."
-            safe_working_directory = script_dir.replace("'", "''")
-            working_directory_setting = f"$action.WorkingDirectory = '{safe_working_directory}'"
+            # Escape single quotes for PowerShell string literal
+            ps_escaped_working_directory = script_dir.replace("'", "''") 
+            working_directory_setting = f"$action.WorkingDirectory = '{ps_escaped_working_directory}'"
         except Exception as e:
              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"
 
+        # Escape paths and args for embedding in PowerShell command string
+        ps_escaped_executable = action_executable_path.replace("'", "''")
+        ps_escaped_arguments = python_arguments.replace("'", "''")
+        ps_escaped_username = username.replace("'", "''")
+        task_name = f"OOTB_UserConnect_{username}"
+        
         # PowerShell command construction
         ps_command = f"""
-        $taskName = "{task_name}"
-        $principal = New-ScheduledTaskPrincipal -UserId "{username}" -LogonType Interactive
+        $taskName = \"{task_name}\"
+        $principal = New-ScheduledTaskPrincipal -UserId '{ps_escaped_username}' -LogonType Interactive
         
         # Action: Run python signal script
-        $action = New-ScheduledTaskAction -Execute '{safe_action_executable}' -Argument '{safe_action_arguments}'
+        $action = New-ScheduledTaskAction -Execute '{ps_escaped_executable}' -Argument '{ps_escaped_arguments}'
         {working_directory_setting}
 
         # Trigger: At Logon for the specified user

{computer_use_ootb_internal-0.0.182 → computer_use_ootb_internal-0.0.184}/src/computer_use_ootb_internal/preparation/excel_prepare.py

@@ -75,21 +75,24 @@ def run_preparation(state):
         # --- End of kill process --- 
 
         # Open the file with Excel maximized on Windows
-        log.info(f"Attempting to open {template_file} with Excel maximized on Windows...")
         try:
-            # Use start command with /max flag on Windows
-            cmd = ['cmd', '/c', 'start', '/max', 'excel', str(template_file)] # Changed app name
-            # Temporarily commented out file opening
-            # result = subprocess.run(cmd, check=False, capture_output=True, text=True)
-            log.info(f"(Skipped) Would open file with command: {' '.join(cmd)}")
-            result = None # Set result to None or mock success if needed elsewhere
+            # Check if template exists and construct command accordingly
+            if template_file.exists():
+                log.info(f"Template file found. Attempting to open {template_file} with Excel maximized...")
+                cmd = ['cmd', '/c', 'start', '/max', 'excel', str(template_file)]
+            else:
+                log.info(f"Template file not found. Attempting to launch Excel maximized...")
+                cmd = ['cmd', '/c', 'start', '/max', 'excel']
+
+            log.info(f"Executing command: {' '.join(cmd)}")
+            result = subprocess.run(cmd, check=False, capture_output=True, text=True, creationflags=subprocess.CREATE_NO_WINDOW) # Add CREATE_NO_WINDOW
 
-            # if result and result.returncode == 0:
-            #     log.info(f"Successfully launched Excel maximized with {template_file}")
-            # else:
-            #     log.error(f"Error opening Excel: {result.stderr.strip() if result else 'Command not run'}")
-            #     if result and result.stdout:
-            #         log.error(f"Stdout from start command: {result.stdout.strip()}")
+            if result.returncode == 0:
+                log.info(f"Successfully executed command for Excel.")
+            else:
+                log.error(f"Error opening Excel: {result.stderr.strip()}")
+                if result.stdout:
+                    log.error(f"Stdout from start command: {result.stdout.strip()}")
         except FileNotFoundError:
              log.error("Error: 'cmd' or 'start' command not found. Ensure system PATH is configured correctly.")
         except Exception as e:

{computer_use_ootb_internal-0.0.182 → computer_use_ootb_internal-0.0.184}/src/computer_use_ootb_internal/preparation/powerpoint_prepare.py

@@ -77,18 +77,22 @@ def run_preparation(state):
         # --- End of kill process --- 
 
         # Open the file with PowerPoint maximized on Windows
-        log.info(f"Attempting to open {template_file} with PowerPoint maximized on Windows...")
         try:
-            # Use start command with /max flag on Windows
-            cmd = ['cmd', '/c', 'start', '/max', 'powerpnt', str(template_file)]
-            result = subprocess.run(cmd, check=False, capture_output=True, text=True)
+            # Check if template exists and construct command accordingly
+            if template_file.exists():
+                log.info(f"Template file found. Attempting to open {template_file} with PowerPoint maximized...")
+                cmd = ['cmd', '/c', 'start', '/max', 'powerpnt', str(template_file)]
+            else:
+                log.info(f"Template file not found. Attempting to launch PowerPoint maximized...")
+                cmd = ['cmd', '/c', 'start', '/max', 'powerpnt']
+
+            log.info(f"Executing command: {' '.join(cmd)}")
+            result = subprocess.run(cmd, check=False, capture_output=True, text=True, creationflags=subprocess.CREATE_NO_WINDOW) # Add CREATE_NO_WINDOW
             
             if result.returncode == 0:
-                log.info(f"Successfully launched PowerPoint maximized with {template_file}")
+                log.info(f"Successfully executed command for PowerPoint.")
             else:
-                # Log stderr for debugging potential start command issues
                 log.error(f"Error opening PowerPoint: {result.stderr.strip()}")
-                # Also log stdout as start command might output info there
                 if result.stdout:
                     log.error(f"Stdout from start command: {result.stdout.strip()}")
         except FileNotFoundError:

{computer_use_ootb_internal-0.0.182 → computer_use_ootb_internal-0.0.184}/src/computer_use_ootb_internal/preparation/pr_prepare.py

@@ -76,22 +76,25 @@ def run_preparation(state):
         # --- End of kill process --- 
 
         # Open the file with Premiere Pro maximized on Windows
-        log.info(f"Attempting to open {template_file} with Premiere Pro maximized on Windows...")
         try:
-            # Use start command with /max flag on Windows.
-            # Assuming the application name for start command includes the year.
-            cmd = ['cmd', '/c', 'start', '/max', '"Adobe Premiere Pro 2024"', str(template_file)] # Updated app name, kept quotes
-            # Temporarily commented out file opening
-            # result = subprocess.run(cmd, check=False, capture_output=True, text=True)
-            log.info(f"(Skipped) Would open file with command: {' '.join(cmd)}")
-            result = None # Set result to None or mock success if needed elsewhere
+            # Check if template exists and construct command accordingly
+            if template_file.exists():
+                log.info(f"Template file found. Attempting to open {template_file} with Premiere Pro maximized...")
+                # Keep quotes around app name if it contains spaces
+                cmd = ['cmd', '/c', 'start', '/max', '"Adobe Premiere Pro 2024"', str(template_file)]
+            else:
+                log.info(f"Template file not found. Attempting to launch Premiere Pro maximized...")
+                cmd = ['cmd', '/c', 'start', '/max', '"Adobe Premiere Pro 2024"']
+
+            log.info(f"Executing command: {' '.join(cmd)}")
+            result = subprocess.run(cmd, check=False, capture_output=True, text=True, creationflags=subprocess.CREATE_NO_WINDOW) # Add CREATE_NO_WINDOW
             
-            # if result and result.returncode == 0:
-            #     log.info(f"Successfully launched Premiere Pro maximized with {template_file}")
-            # else:
-            #     log.error(f"Error opening Premiere Pro: {result.stderr.strip() if result else 'Command not run'}")
-            #     if result and result.stdout:
-            #         log.error(f"Stdout from start command: {result.stdout.strip()}")
+            if result.returncode == 0:
+                log.info(f"Successfully executed command for Premiere Pro.")
+            else:
+                log.error(f"Error opening Premiere Pro: {result.stderr.strip()}")
+                if result.stdout:
+                    log.error(f"Stdout from start command: {result.stdout.strip()}")
         except FileNotFoundError:
              log.error("Error: 'cmd' or 'start' command not found. Ensure system PATH is configured correctly.")
         except Exception as e:

{computer_use_ootb_internal-0.0.182 → computer_use_ootb_internal-0.0.184}/src/computer_use_ootb_internal/preparation/word_prepare.py

@@ -75,21 +75,24 @@ def run_preparation(state):
         # --- End of kill process --- 
 
         # Open the file with Word maximized on Windows
-        log.info(f"Attempting to open {template_file} with Word maximized on Windows...")
         try:
-            # Use start command with /max flag on Windows
-            cmd = ['cmd', '/c', 'start', '/max', 'winword', str(template_file)] # Changed app name
-            # Temporarily commented out file opening
-            # result = subprocess.run(cmd, check=False, capture_output=True, text=True)
-            log.info(f"(Skipped) Would open file with command: {' '.join(cmd)}")
-            result = None # Set result to None or mock success if needed elsewhere
+            # Check if template exists and construct command accordingly
+            if template_file.exists():
+                log.info(f"Template file found. Attempting to open {template_file} with Word maximized...")
+                cmd = ['cmd', '/c', 'start', '/max', 'winword', str(template_file)]
+            else:
+                log.info(f"Template file not found. Attempting to launch Word maximized...")
+                cmd = ['cmd', '/c', 'start', '/max', 'winword']
+
+            log.info(f"Executing command: {' '.join(cmd)}")
+            result = subprocess.run(cmd, check=False, capture_output=True, text=True, creationflags=subprocess.CREATE_NO_WINDOW) # Add CREATE_NO_WINDOW
             
-            # if result and result.returncode == 0:
-            #     log.info(f"Successfully launched Word maximized with {template_file}")
-            # else:
-            #     log.error(f"Error opening Word: {result.stderr.strip() if result else 'Command not run'}")
-            #     if result and result.stdout:
-            #         log.error(f"Stdout from start command: {result.stdout.strip()}")
+            if result.returncode == 0:
+                log.info(f"Successfully executed command for Word.")
+            else:
+                log.error(f"Error opening Word: {result.stderr.strip()}")
+                if result.stdout:
+                    log.error(f"Stdout from start command: {result.stdout.strip()}")
         except FileNotFoundError:
              log.error("Error: 'cmd' or 'start' command not found. Ensure system PATH is configured correctly.")
         except Exception as e: