feat(browser-agent): Fix profile login setup with NovaActExecutor

Major improvements to local browser agent configuration and profile management:

## Profile Login Setup
- Add setup_login command type to nova_act_wrapper.py
- Opens browser with headless=false for manual login
- Uses time.sleep() instead of input() to avoid stdin issues
- Automatically saves session after 5-minute timeout
- Refactor profile_commands.rs to use NovaActExecutor (consistent with validate_profile)

## Path Resolution & Python Venv
- Fix find_python_executable() to use venv symlink directly (not canonicalize)
- Update all profile commands to use venv Python instead of uvx/python3
- Fix profile_manager.py path resolution for macOS app bundle
- Add proper logging for Python and script paths

## Configuration Persistence
- Remove strict validation from Config::from_file()
- Allow incomplete configs to load (e.g., missing API key)
- Add validate_for_polling() for strict validation when needed
- Fix config reload in script execution for immediate effect

## Python Environment Setup
- Add UV verification before use (test with --version)
- Automatic fallback to PATH search if UV broken
- Enhanced error messages with setup instructions

## Nova Act Authentication
- Smart API key detection (arg, env var, boto session)
- Avoid conflicts between API key and boto_session
- Add comprehensive session startup logging

## Build & Deployment
- Update Makefile with package target for DMG deployment
- Add examples directory to Tauri bundle resources
- Improve script_executor and test_commands path resolution

## UI Improvements
- Better config loading logging in ConfigScreen.tsx
- Enhanced Python environment setup progress display

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: guyernest

lambda/tools/local-browser-agent/Makefile

@@ -14,7 +14,9 @@ help:
 	@echo ""
 	@echo "Development:"
 	@echo "  make dev              Run in development mode with hot reload (opens Tauri UI)"
-	@echo "  make build            Build release binary"
+	@echo "  make build            Build release binary with DMG installer"
+	@echo "  make build-bin        Build binary only (faster, no DMG bundle)"
+	@echo "  make package          Create deployment package (includes DMG, Python, docs)"
 	@echo "  make run              Run the agent (requires config.yaml)"
 	@echo "  make run-config       Run with custom config (CONFIG=/path/to/config.yaml)"
 	@echo ""
@@ -89,10 +91,82 @@ install-rust:
 # Build
 build:
 	@echo "Building Local Browser Agent..."
+	@# Remove .venv from python directory to avoid bundling it (320MB!)
+	@rm -rf python/.venv python/__pycache__ python/*.pyc
+	@cd src-tauri && cargo tauri build
+	@echo ""
+	@echo "Build complete!"
+	@echo "  Binary:  ./src-tauri/target/release/local-browser-agent"
+	@echo "  App:     ./src-tauri/target/release/bundle/macos/Local Browser Agent.app"
+	@echo "  DMG:     ./src-tauri/target/release/bundle/dmg/*.dmg"
+
+# Build binary only (faster, no bundle)
+build-bin:
+	@echo "Building binary only (no bundle)..."
 	@cd ui && npm run build
 	@cd src-tauri && cargo build --release
 	@echo "Build complete: ./src-tauri/target/release/local-browser-agent"
 
+# Create deployment package
+package:
+	@echo "=================================="
+	@echo "Creating deployment package..."
+	@echo "=================================="
+	@echo ""
+	@# Check if build exists
+	@if [ ! -f "src-tauri/target/release/bundle/macos/Local Browser Agent.app/Contents/MacOS/local-browser-agent" ]; then \
+		echo "❌ Build not found. Running 'make build' first..."; \
+		make build; \
+	fi
+	@# Create deployment directory
+	@rm -rf deployment-package
+	@mkdir -p deployment-package
+	@echo "📦 Packaging files..."
+	@# Copy DMG installer
+	@echo "  - DMG installer"
+	@cp src-tauri/target/release/bundle/dmg/*.dmg deployment-package/ 2>/dev/null || true
+	@# Copy app bundle
+	@echo "  - App bundle"
+	@cp -r "src-tauri/target/release/bundle/macos/Local Browser Agent.app" deployment-package/ 2>/dev/null || true
+	@# Copy Python directory
+	@echo "  - Python scripts"
+	@mkdir -p deployment-package/python
+	@cp python/*.py deployment-package/python/
+	@cp python/requirements.txt deployment-package/python/
+	@# Copy examples directory
+	@echo "  - Examples"
+	@cp -r examples deployment-package/
+	@# Copy configuration template
+	@echo "  - Configuration template"
+	@cp config.example.yaml deployment-package/config.yaml
+	@# Create setup script
+	@echo "  - Setup script"
+	@cp SETUP.sh.template deployment-package/SETUP.sh
+	@chmod +x deployment-package/SETUP.sh
+	@# Copy README template
+	@echo "  - README"
+	@cp README.template.md deployment-package/README.md
+	@# Create compressed archive
+	@echo "  - Creating archive"
+	@tar -czf browser-agent-deployment.tar.gz deployment-package/
+	@# Show results
+	@echo ""
+	@echo "=================================="
+	@echo "✅ Deployment Package Created!"
+	@echo "=================================="
+	@echo ""
+	@echo "Archive: browser-agent-deployment.tar.gz"
+	@ls -lh browser-agent-deployment.tar.gz
+	@echo ""
+	@echo "Package contents:"
+	@ls -lh deployment-package/
+	@echo ""
+	@echo "To deploy to UK Mac:"
+	@echo "  1. Transfer: scp browser-agent-deployment.tar.gz user@uk-mac:"
+	@echo "  2. Extract: tar -xzf browser-agent-deployment.tar.gz"
+	@echo "  3. Setup:   cd deployment-package && ./SETUP.sh"
+	@echo ""
+
 # Development
 dev:
 	@echo "Starting development server..."

lambda/tools/local-browser-agent/python/nova_act_wrapper.py

@@ -29,7 +29,7 @@ def execute_browser_command(command: Dict[str, Any]) -> Dict[str, Any]:
 
     Args:
         command: Dictionary containing:
-            - command_type: 'start_session', 'act', 'script', 'end_session', or 'validate_profile'
+            - command_type: 'start_session', 'act', 'script', 'end_session', 'validate_profile', or 'setup_login'
             - prompt: Natural language instruction (for 'act')
             - steps: List of script steps (for 'script')
             - starting_page: Initial URL (for 'start_session' or 'script')
@@ -41,6 +41,7 @@ def execute_browser_command(command: Dict[str, Any]) -> Dict[str, Any]:
             - schema: JSON schema for output
             - headless: Run headless mode
             - record_video: Record video
+            - profile_name: Profile name (for 'setup_login')
 
     Returns:
         Dictionary with execution result
@@ -58,6 +59,8 @@ def execute_browser_command(command: Dict[str, Any]) -> Dict[str, Any]:
             return end_session(command)
         elif command_type == 'validate_profile':
             return validate_profile(command)
+        elif command_type == 'setup_login':
+            return setup_login(command)
         else:
             return {
                 "success": False,
@@ -160,14 +163,16 @@ def execute_act(command: Dict[str, Any]) -> Dict[str, Any]:
     print("[DEMO MODE] Forcing profile to: Bt_broadband", file=sys.stderr)
     from profile_manager import ProfileManager
     profile_manager = ProfileManager()
+    profile_name = "Bt_broadband"
     try:
-        profile_config = profile_manager.get_nova_act_config("Bt_broadband", clone_for_parallel=False)
+        profile_config = profile_manager.get_nova_act_config(profile_name, clone_for_parallel=False)
         user_data_dir = profile_config["user_data_dir"]
         clone_user_data_dir = profile_config["clone_user_data_dir"]
-        print(f"[DEMO MODE] Using profile path: {user_data_dir}", file=sys.stderr)
+        print(f"[DEMO MODE] Loaded profile '{profile_name}' from path: {user_data_dir}", file=sys.stderr)
     except Exception as e:
-        print(f"[DEMO MODE] Warning: Could not load Bt_broadband profile: {e}", file=sys.stderr)
+        print(f"[DEMO MODE] Warning: Could not load {profile_name} profile: {e}", file=sys.stderr)
         print(f"[DEMO MODE] Continuing with original user_data_dir: {user_data_dir}", file=sys.stderr)
+        profile_name = "default" if not user_data_dir else "custom"
 
     # Create boto3 session with local credentials
     boto_session = boto3.Session(profile_name=aws_profile)
@@ -213,6 +218,18 @@ def execute_act(command: Dict[str, Any]) -> Dict[str, Any]:
         else:
             nova_act_kwargs["boto_session"] = boto_session
 
+        # Log comprehensive session startup information
+        print(f"[INFO] Starting browser session with:", file=sys.stderr)
+        print(f"  - Profile: {profile_name}", file=sys.stderr)
+        print(f"  - Profile Path: {user_data_dir}", file=sys.stderr)
+        print(f"  - Headless Mode: {headless}", file=sys.stderr)
+        print(f"  - Clone Profile: {clone_user_data_dir if clone_user_data_dir is not None else 'not set (NovaAct default)'}", file=sys.stderr)
+        print(f"  - Starting Page: {starting_page or 'none'}", file=sys.stderr)
+        print(f"  - Record Video: {record_video}", file=sys.stderr)
+        print(f"  - Max Steps: {max_steps}", file=sys.stderr)
+        print(f"  - Timeout: {timeout}s", file=sys.stderr)
+        print(f"  - Session ID: {session_id or 'auto-generated'}", file=sys.stderr)
+
         with NovaAct(**nova_act_kwargs) as nova:
             # Execute act command
             result = nova.act(
@@ -503,6 +520,131 @@ def validate_profile(command: Dict[str, Any]) -> Dict[str, Any]:
     return out
 
 
+def setup_login(command: Dict[str, Any]) -> Dict[str, Any]:
+    """Setup interactive login for a profile.
+
+    Opens a browser with the profile's user_data_dir, navigates to the starting_url,
+    and waits for a timeout period to allow the user to manually log in.
+    When the browser closes or timeout expires, the session is automatically saved.
+
+    Args:
+        command: Dictionary containing:
+            - profile_name: Name of the profile
+            - starting_url: URL to navigate to for login
+            - timeout: Timeout in seconds (default: 300 = 5 minutes)
+
+    Returns:
+        Dictionary with success status
+    """
+    profile_name = command.get("profile_name")
+    starting_url = command.get("starting_url")
+
+    if not profile_name:
+        return {"success": False, "error": "profile_name is required"}
+    if not starting_url:
+        return {"success": False, "error": "starting_url is required"}
+
+    try:
+        from profile_manager import ProfileManager
+
+        # Initialize profile manager
+        profile_manager = ProfileManager()
+
+        # Check if profile exists, create if not
+        profile = profile_manager.get_profile(profile_name)
+        if not profile:
+            print(f"Creating new profile: {profile_name}", file=sys.stderr)
+            profile = profile_manager.create_profile(
+                profile_name=profile_name,
+                description=f"Profile with authenticated session for {starting_url}",
+                tags=["authenticated"],
+                auto_login_sites=[starting_url]
+            )
+        else:
+            print(f"Using existing profile: {profile_name}", file=sys.stderr)
+
+        # Mark profile as requiring human login
+        profile_manager.mark_profile_for_login(
+            profile_name=profile_name,
+            requires_human=True,
+            notes=f"Manual login required for {starting_url}"
+        )
+
+        # Get Nova Act config
+        config = profile_manager.get_nova_act_config(profile_name, clone_for_parallel=False)
+        user_data_dir = config["user_data_dir"]
+
+        # Determine timeout (default 5 minutes)
+        timeout = command.get("timeout", 300)
+
+        # Get authentication credentials
+        nova_act_api_key = os.environ.get('NOVA_ACT_API_KEY')
+        boto_session = None
+        if not nova_act_api_key:
+            try:
+                aws_profile = command.get('aws_profile', 'browser-agent')
+                boto_session = boto3.Session(profile_name=aws_profile)
+            except Exception:
+                pass
+
+        # Build NovaAct kwargs
+        nova_act_kwargs = {
+            "starting_page": starting_url,
+            "user_data_dir": user_data_dir,
+            "clone_user_data_dir": False,  # Don't clone to preserve session
+            "headless": False,  # Must be visible for human login
+            "ignore_https_errors": True,
+        }
+
+        if nova_act_api_key:
+            nova_act_kwargs["nova_act_api_key"] = nova_act_api_key
+        elif boto_session:
+            nova_act_kwargs["boto_session"] = boto_session
+
+        print(f"", file=sys.stderr)
+        print(f"╔═══════════════════════════════════════════════════════════╗", file=sys.stderr)
+        print(f"║  PROFILE LOGIN SETUP                                      ║", file=sys.stderr)
+        print(f"╠═══════════════════════════════════════════════════════════╣", file=sys.stderr)
+        print(f"║  Profile: {profile_name:<48}║", file=sys.stderr)
+        print(f"║  URL:     {starting_url[:48]:<48}║", file=sys.stderr)
+        print(f"║  Timeout: {timeout} seconds{'':<38}║", file=sys.stderr)
+        print(f"╠═══════════════════════════════════════════════════════════╣", file=sys.stderr)
+        print(f"║  A browser window will open. Please log in manually.     ║", file=sys.stderr)
+        print(f"║  The browser will stay open for {timeout//60} minutes.{'':<23}║", file=sys.stderr)
+        print(f"║  Your login session will be saved automatically.         ║", file=sys.stderr)
+        print(f"║  You can close the browser when done.                    ║", file=sys.stderr)
+        print(f"╚═══════════════════════════════════════════════════════════╝", file=sys.stderr)
+        print(f"", file=sys.stderr)
+
+        # Open browser for manual login
+        import time
+        with NovaAct(**nova_act_kwargs) as nova:
+            # Just wait for the timeout - user can log in during this time
+            # The browser will stay open and visible
+            print(f"Browser opened. Waiting {timeout} seconds for you to complete login...", file=sys.stderr)
+            time.sleep(timeout)
+            print(f"Timeout reached. Closing browser and saving session...", file=sys.stderr)
+
+        print(f"", file=sys.stderr)
+        print(f"✓ Profile '{profile_name}' login setup completed!", file=sys.stderr)
+        print(f"  User data directory: {user_data_dir}", file=sys.stderr)
+        print(f"  Future scripts can reuse this authenticated session", file=sys.stderr)
+
+        return {
+            "success": True,
+            "message": f"Login setup completed for profile '{profile_name}'",
+            "profile_name": profile_name,
+            "user_data_dir": user_data_dir,
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Failed to setup login: {str(e)}",
+            "traceback": traceback.format_exc()
+        }
+
+
 def main():
     """
     Main entry point

lambda/tools/local-browser-agent/python/script_executor.py

@@ -229,15 +229,38 @@ def execute_script(self, script: Dict[str, Any]) -> Dict[str, Any]:
 
             # Add Nova Act API key if provided (otherwise uses NOVA_ACT_API_KEY env var)
             # Note: Cannot use both API key and boto_session
-            if self.nova_act_api_key:
-                nova_act_kwargs["nova_act_api_key"] = self.nova_act_api_key
+            # Check for API key from: 1) argument, 2) env var
+            api_key_from_arg = self.nova_act_api_key and self.nova_act_api_key.strip()
+            api_key_from_env = os.environ.get("NOVA_ACT_API_KEY")
+
+            if api_key_from_arg:
+                # Explicit API key provided via argument
+                nova_act_kwargs["nova_act_api_key"] = self.nova_act_api_key.strip()
+            elif api_key_from_env:
+                # API key in environment - NovaAct will pick it up automatically
+                # Do NOT pass boto_session as it conflicts with API key
+                pass
             else:
-                # Use boto session for IAM-based auth (requires allowlist)
+                # No API key - use boto session for IAM-based auth (requires allowlist)
                 nova_act_kwargs["boto_session"] = self.boto_session
 
             # Track active user_data_dir for validation steps
             self._active_user_data_dir = profile_user_data_dir
 
+            # Log comprehensive session startup information
+            print(f"[INFO] Starting browser session with:", file=sys.stderr)
+            print(f"  - Script: {name}", file=sys.stderr)
+            print(f"  - Profile: {profile_name}", file=sys.stderr)
+            print(f"  - Profile Path: {profile_user_data_dir}", file=sys.stderr)
+            print(f"  - Headless Mode: {nova_act_kwargs['headless']}", file=sys.stderr)
+            print(f"  - Clone Profile: {clone_user_data_dir}", file=sys.stderr)
+            print(f"  - Starting Page: {starting_page}", file=sys.stderr)
+            print(f"  - Record Video: {self.record_video}", file=sys.stderr)
+            print(f"  - Max Steps per Action: {self.max_steps}", file=sys.stderr)
+            print(f"  - Timeout per Action: {self.timeout}s", file=sys.stderr)
+            print(f"  - Navigation Timeout: {nova_act_kwargs.get('go_to_url_timeout', 'default')}s", file=sys.stderr)
+            print(f"  - Total Steps: {len(steps)}", file=sys.stderr)
+
             # Create NovaAct instance
             nova = NovaAct(**nova_act_kwargs)
             nova.start()

lambda/tools/local-browser-agent/src-tauri/src/config.rs

@@ -45,6 +45,21 @@ fn default_heartbeat_interval() -> u64 {
 }
 
 impl Config {
+    /// Create a default minimal config (for when no config file exists)
+    pub fn default_minimal() -> Self {
+        Config {
+            activity_arn: String::new(),
+            aws_profile: "default".to_string(),
+            s3_bucket: String::new(),
+            user_data_dir: None,
+            ui_port: default_ui_port(),
+            nova_act_api_key: None,
+            headless: false,
+            heartbeat_interval: default_heartbeat_interval(),
+            aws_region: None,
+        }
+    }
+
     /// Load configuration from YAML file
     pub fn from_file(path: &PathBuf) -> Result<Self> {
         let contents = std::fs::read_to_string(path)
@@ -53,23 +68,38 @@ impl Config {
         let config: Config = serde_yaml::from_str(&contents)
             .context("Failed to parse config file")?;
 
-        config.validate()?;
+        // Don't validate here - allow incomplete configs for testing/configuration
+        // Validation will happen when trying to use specific features
 
         Ok(config)
     }
 
-    /// Validate configuration
-    fn validate(&self) -> Result<()> {
+    /// Validate configuration for activity polling
+    /// This is stricter than basic validation - requires all fields for polling to work
+    pub fn validate_for_polling(&self) -> Result<()> {
         if self.activity_arn.is_empty() {
-            anyhow::bail!("activity_arn cannot be empty");
+            anyhow::bail!("activity_arn cannot be empty for activity polling");
         }
 
         if self.aws_profile.is_empty() {
             anyhow::bail!("aws_profile cannot be empty");
         }
 
         if self.s3_bucket.is_empty() {
-            anyhow::bail!("s3_bucket cannot be empty");
+            anyhow::bail!("s3_bucket cannot be empty for activity polling");
+        }
+
+        if self.heartbeat_interval == 0 {
+            anyhow::bail!("heartbeat_interval must be greater than 0");
+        }
+
+        Ok(())
+    }
+
+    /// Basic validation - just ensures critical fields are valid
+    fn validate(&self) -> Result<()> {
+        if self.aws_profile.is_empty() {
+            anyhow::bail!("aws_profile cannot be empty");
         }
 
         if self.heartbeat_interval == 0 {