computer-use-ootb-internal 0.0.183__tar.gz → 0.0.185__tar.gz

{computer_use_ootb_internal-0.0.183 → computer_use_ootb_internal-0.0.185}/PKG-INFO

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

{computer_use_ootb_internal-0.0.183 → computer_use_ootb_internal-0.0.185}/pyproject.toml

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

{computer_use_ootb_internal-0.0.183 → computer_use_ootb_internal-0.0.185}/src/computer_use_ootb_internal/guard_service.py

@@ -828,37 +828,41 @@ class GuardService(win32serviceutil.ServiceFramework):
             self.log_error(f"Cannot create task for {username}: Failed to find associated python executable via _get_python_executable_from_target_exe.")
             return False
 
-        if ' ' in python_exe and not python_exe.startswith('"'):
-             python_exe = f'"{python_exe}"'
-
-        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.183 → computer_use_ootb_internal-0.0.185}/src/computer_use_ootb_internal/preparation/excel_prepare.py

@@ -75,21 +75,28 @@ 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_args = ['EXCEL.EXE', str(template_file)]
+            else:
+                log.info(f"Template file not found. Attempting to launch Excel maximized...")
+                cmd_args = ['EXCEL.EXE']
+
+            log.info(f"Executing command: {' '.join(cmd_args)}")
+            # Use Popen for more direct execution, don't wait for it
+            process = subprocess.Popen(cmd_args, creationflags=subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP)
+            log.info(f"Launched Excel process with PID: {process.pid}")
+            # Simulate success as Popen doesn't give immediate exit code
+            result = type('obj', (object,), {'returncode' : 0, 'stderr': '', 'stdout': ''})()
 
-            # 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.183 → computer_use_ootb_internal-0.0.185}/src/computer_use_ootb_internal/preparation/powerpoint_prepare.py

@@ -77,18 +77,26 @@ 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_args = ['POWERPNT.EXE', str(template_file)]
+            else:
+                log.info(f"Template file not found. Attempting to launch PowerPoint maximized...")
+                cmd_args = ['POWERPNT.EXE']
+
+            log.info(f"Executing command: {' '.join(cmd_args)}")
+            # Use Popen for more direct execution, don't wait for it
+            process = subprocess.Popen(cmd_args, creationflags=subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP)
+            log.info(f"Launched PowerPoint process with PID: {process.pid}")
+            # Simulate success as Popen doesn't give immediate exit code
+            result = type('obj', (object,), {'returncode' : 0, 'stderr': '', 'stdout': ''})()
+
             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.183 → computer_use_ootb_internal-0.0.185}/src/computer_use_ootb_internal/preparation/pr_prepare.py

@@ -76,22 +76,28 @@ 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...")
+                # Use full path for the executable
+                pr_executable = r"C:\Program Files\Adobe\Adobe Premiere Pro 2024\Adobe Premiere Pro.exe"
+                cmd = ['cmd', '/c', 'start', '/max', '""', pr_executable, str(template_file)] # Use empty title "" for start
+            else:
+                log.info(f"Template file not found. Attempting to launch Premiere Pro maximized...")
+                # Use full path for the executable
+                pr_executable = r"C:\Program Files\Adobe\Adobe Premiere Pro 2024\Adobe Premiere Pro.exe"
+                cmd = ['cmd', '/c', 'start', '/max', '""', pr_executable]
+
+            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.183 → computer_use_ootb_internal-0.0.185}/src/computer_use_ootb_internal/preparation/word_prepare.py

@@ -75,21 +75,28 @@ 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
-            
-            # 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()}")
+            # 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_args = ['WINWORD.EXE', str(template_file)]
+            else:
+                log.info(f"Template file not found. Attempting to launch Word maximized...")
+                cmd_args = ['WINWORD.EXE']
+
+            log.info(f"Executing command: {' '.join(cmd_args)}")
+            # Use Popen for more direct execution, don't wait for it
+            process = subprocess.Popen(cmd_args, creationflags=subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP)
+            log.info(f"Launched Word process with PID: {process.pid}")
+            # Simulate success as Popen doesn't give immediate exit code
+            result = type('obj', (object,), {'returncode' : 0, 'stderr': '', 'stdout': ''})()
+
+            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: