@kritchoff/agent-browser 0.9.44 → 0.9.47

package/docker-compose.sdk.yml

@@ -19,6 +19,7 @@ services:
       - /dev/kvm:/dev/kvm
     volumes:
       - avd-data:/root/.android
+      - ./cache/snapshots:/root/.android/avd/Pixel_6_API_34.avd/snapshots
     healthcheck:
       test: ["CMD", "curl", "-f", "http://localhost:9224/json/version"]
       interval: 10s

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kritchoff/agent-browser",
-  "version": "0.9.44",
+  "version": "0.9.47",
   "description": "Headless browser automation CLI for AI agents",
   "type": "module",
   "main": "dist/index.js",

package/sdk.sh

@@ -2,7 +2,7 @@
 # Agent Browser SDK Wrapper
 # 
 # A user-friendly entry point for AI Agents to interact with the Android Browser Environment.
-# Handles "Lazy Snapshot" logic for instant startups.
+# Handles "Hyper-Speed Snapshot" logic for instant startups.
 #
 # Usage:
 #   ./sdk.sh start      - Start the environment (Cold boot 1st time, Warm boot after)
@@ -13,14 +13,13 @@
 
 set -e
 
-# Set high timeouts for large image downloads (Production robustness)
-# This helps prevent 'TLS handshake timeout' on slow connections
+# Set high timeouts for large image downloads
 export COMPOSE_HTTP_TIMEOUT=900
 export DOCKER_CLIENT_TIMEOUT=900
 
 SDK_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 CACHE_DIR="$SDK_ROOT/cache"
-SNAPSHOT_FILE="$CACHE_DIR/baseline.tar.gz"
+SNAPSHOT_DIR="$CACHE_DIR/snapshots/quickboot"
 
 # Default to production/local build unless --dist is used
 COMPOSE_FILE="$SDK_ROOT/docker-compose.prod.yml"
@@ -46,7 +45,7 @@ while [[ $# -gt 0 ]]; do
 done
 
 # Ensure cache dir exists
-mkdir -p "$CACHE_DIR"
+mkdir -p "$CACHE_DIR/snapshots"
 
 log_info() { echo -e "${BLUE}[SDK]${NC} $1"; }
 log_success() { echo -e "${GREEN}[SDK]${NC} $1"; }
@@ -54,12 +53,11 @@ log_warn() { echo -e "${YELLOW}[SDK]${NC} $1"; }
 log_error() { echo -e "${RED}[SDK]${NC} $1"; }
 
 pull_images_with_retry() {
-    # Only pull if we are using the distribution compose file (which uses images)
     if [[ "$COMPOSE_FILE" != *"docker-compose.sdk.yml" ]]; then
         return 0
     fi
 
-    local max_retries=5
+    local max_retries=10
     local count=0
     
     log_info "Please wait while we get things ready..."
@@ -70,8 +68,8 @@ pull_images_with_retry() {
         fi
         
         count=$((count + 1))
-        log_warn "Download failed/interrupted. Retrying ($count/$max_retries)..."
-        sleep 5
+        log_warn "Download failed/interrupted. Retrying ($count/$max_retries) in 10s..."
+        sleep 10
     done
     
     log_error "Failed to download images after $max_retries attempts. Please check your internet connection."
@@ -80,97 +78,49 @@ pull_images_with_retry() {
 
 cmd_start() {
     log_info "Initializing Agent Environment (using $COMPOSE_FILE)..."
-
-    # Export COMPOSE_FILE so start.sh (which might call docker compose) uses it
-    # Note: start.sh needs to be updated to respect COMPOSE_FILE if it doesn't already
     export COMPOSE_FILE="$COMPOSE_FILE"
-
-    # Ensure images are present (Production robustness)
     pull_images_with_retry
 
-    # --- ALWAYS CLEAN UP PREVIOUS STATE ---
-    # This prevents network namespace corruption and port binding failures on warm boots
     log_info "Cleaning up previous container state..."
     docker compose -f "$COMPOSE_FILE" down -v --remove-orphans >/dev/null 2>&1 || true
 
-    if [ -f "$SNAPSHOT_FILE" ]; then
+    if [ -d "$SNAPSHOT_DIR" ]; then
         # === WARM START ===
-        log_success "Found cached baseline snapshot. Performing WARM BOOT..."
-        "$SDK_ROOT/start.sh" --snapshot "$SNAPSHOT_FILE"
-        
-                # Verify port mapping for warm start too
-                cd "$SDK_ROOT"
-                AGENT_CONT=$(docker compose ps -q agent-service)
-                if [ -n "$AGENT_CONT" ] && ! docker port "$AGENT_CONT" 3000 >/dev/null 2>&1; then
-                    log_warn "Port 3000 (Host 32001) is not mapped! Container config is stale."
-                    log_info "Forcing full restart to apply network settings..."
-                    docker compose -f "$COMPOSE_FILE" down -v --remove-orphans
-                    
-                    log_info "Waiting for ports to release..."
-                    sleep 5
-                    
-                    "$SDK_ROOT/start.sh" --snapshot "$SNAPSHOT_FILE"
-                fi
-            else
-                # === COLD START & FREEZE ===
-                log_warn "No baseline found. Performing FIRST RUN SETUP (Cold Boot)..."
-                log_warn "This will take ~60-90 seconds, but only once."
-        
-                # Start in background to wait for it
-                "$SDK_ROOT/start.sh" &
-                START_PID=$!
-                wait $START_PID
-                
-                # Check if start was successful
-                if [ $? -ne 0 ]; then
-                    log_error "Startup failed."
-                    exit 1
-                fi
+        log_success "Found cached baseline snapshot. Performing HYPER-SPEED WARM BOOT..."
+        export EMULATOR_SNAPSHOT_NAME="quickboot"
+        "$SDK_ROOT/start.sh"
+    else
+        # === COLD START & FREEZE ===
+        log_warn "No baseline found. Performing FIRST RUN SETUP (Cold Boot)..."
+        log_warn "This will take ~60-90 seconds, but only once."
+
+        export EMULATOR_SNAPSHOT_NAME=""
+
+        "$SDK_ROOT/start.sh" &
+        START_PID=$!
+        wait $START_PID
         
-                # We need to find the container ID to send the adb command
-                # We use docker compose to find it reliably
-                cd "$SDK_ROOT"
-                CONTAINER=$(docker compose ps -q android-service)
-                AGENT_CONT=$(docker compose ps -q agent-service)
-                
-                if [ -z "$CONTAINER" ]; then
-                    log_error "Error: Android container not found."
-                    exit 1
-                fi
+        if [ $? -ne 0 ]; then
+            log_error "Startup failed."
+            exit 1
+        fi
+
+        cd "$SDK_ROOT"
+        CONTAINER=$(docker compose ps -q android-service)
         
-                # SELF-HEAL: Verify port 3000 is actually mapped
-                if ! docker port "$AGENT_CONT" 3000 >/dev/null 2>&1; then
-                    log_warn "Port 3000 (Host 32001) is not mapped! Container config is stale."
-                    log_info "Forcing full restart to apply network settings..."
-                    docker compose -f "$COMPOSE_FILE" down -v --remove-orphans
-                    
-                    log_info "Waiting for ports to release..."
-                    sleep 5
-                    
-                    "$SDK_ROOT/start.sh"
-                    
-                    # Re-fetch container ID after restart
-                    CONTAINER=$(docker compose ps -q android-service)
-                fi
-
-        # 1. Save snapshot inside emulator
+        if [ -z "$CONTAINER" ]; then
+            log_error "Error: Android container not found."
+            exit 1
+        fi
+
         log_info "Saving emulator state (quickboot)..."
         if docker exec "$CONTAINER" adb emu avd snapshot save quickboot; then
-             log_success "Snapshot saved inside emulator."
+             log_success "Snapshot saved to host volume."
+             log_success "Setup Complete! Future runs will launch instantly."
         else
              log_error "Failed to save snapshot inside emulator."
              exit 1
         fi
-        
-        # 2. Export to host
-        log_info "Exporting to cache..."
-        if "$SDK_ROOT/scripts/snapshot_manager.sh" export quickboot "$SNAPSHOT_FILE"; then
-            log_success "Snapshot exported to $SNAPSHOT_FILE"
-            log_success "Setup Complete! Future runs will launch in ~20 seconds."
-        else
-            log_error "Failed to export snapshot."
-            # Don't exit, environment is still running
-        fi
     fi
 }
 
@@ -195,17 +145,13 @@ cmd_reset() {
 }
 
 cmd_agent() {
-    # Forward commands to the native agent binary or script
-    # Assuming 'agent' binary is in $SDK_ROOT/agent or bin/agent-browser
     if [ -f "$SDK_ROOT/agent" ]; then
         "$SDK_ROOT/agent" "$@"
     else
-        # Fallback to bin/agent-browser.js if binary not built/linked
         node "$SDK_ROOT/bin/agent-browser.js" "$@"
     fi
 }
 
-# Main Dispatch
 case "$1" in
     start)
         cmd_start
@@ -224,7 +170,7 @@ case "$1" in
         cmd_agent "$@"
         ;;
     *)
-        echo "Usage: $0 {start|stop|reset|agent}"
+        echo "Usage: $0 {start|stop|clean|reset|agent}"
         exit 1
         ;;
 esac

package/start.sh

@@ -54,38 +54,6 @@ docker compose -f "${COMPOSE_FILE:-docker-compose.prod.yml}" up -d --build --rem
 ANDROID_CONTAINER=$(docker compose -f "${COMPOSE_FILE:-docker-compose.prod.yml}" ps -q android-service)
 AGENT_CONTAINER=$(docker compose -f "${COMPOSE_FILE:-docker-compose.prod.yml}" ps -q agent-service)
 
-# 2b. Import Snapshot (if requested)
-if [ -n "$SNAPSHOT_PATH" ]; then
-    echo -e "\n${YELLOW}[2.5/4] Importing Snapshot: $SNAPSHOT_PATH...${NC}"
-    
-    # Wait for container to be responsive
-    echo -n "      Waiting for container to be ready for import... "
-    until docker exec "$ANDROID_CONTAINER" echo "ready" &>/dev/null; do
-        sleep 1
-    done
-    echo -e "${GREEN}OK${NC}"
-
-    # Import
-    if "$SCRIPT_DIR/scripts/snapshot_manager.sh" import "$SNAPSHOT_PATH" "w8rl_imported"; then
-        echo -e "${GREEN}      Snapshot imported successfully.${NC}"
-        
-        # Configure emulator to load this snapshot
-        # We set the env var in the container for the next boot
-        # (This assumes the entrypoint script respects EMULATOR_SNAPSHOT_NAME)
-        # For now, we'll rely on the default behavior or standard AVD loading
-        
-        echo "      Restarting services to load snapshot..."
-        docker compose -f "${COMPOSE_FILE:-docker-compose.prod.yml}" restart android-service agent-service
-        
-        # Update container IDs after restart
-        ANDROID_CONTAINER=$(docker compose -f "${COMPOSE_FILE:-docker-compose.prod.yml}" ps -q android-service)
-        AGENT_CONTAINER=$(docker compose -f "${COMPOSE_FILE:-docker-compose.prod.yml}" ps -q agent-service)
-    else
-        echo -e "${RED}Error: Failed to import snapshot.${NC}"
-        exit 1
-    fi
-fi
-
 # 3. Wait for Readiness
 echo -e "\n${YELLOW}[3/4] Waiting for Initialization...${NC}"
 
@@ -96,17 +64,37 @@ wait_for_log() {
     
     echo -n "      Waiting for $label... "
     until docker logs "$container" 2>&1 | grep -q "$pattern"; do
-        sleep 2
+        sleep 1 # Faster polling
     done
     echo -e "${GREEN}Done!${NC}"
 }
 
-wait_for_log "$ANDROID_CONTAINER" "Emulator boot complete" "Android Emulator Boot"
-wait_for_log "$ANDROID_CONTAINER" "APK installation complete" "WootzApp Installation"
-wait_for_log "$ANDROID_CONTAINER" "CDP Bridge ready" "CDP Bridge"
-# Daemon logs "Daemon listening on TCP 0.0.0.0:3000" in direct mode
+if [ -z "$SNAPSHOT_PATH" ] && [ -z "$EMULATOR_SNAPSHOT_NAME" ]; then
+    # --- COLD BOOT PATH (Wait for everything) ---
+    wait_for_log "$ANDROID_CONTAINER" "Emulator boot complete" "Android Emulator Boot"
+    wait_for_log "$ANDROID_CONTAINER" "APK installation complete" "WootzApp Installation"
+    wait_for_log "$ANDROID_CONTAINER" "CDP Bridge ready" "CDP Bridge"
+else
+    # --- WARM BOOT PATH (Hyper-Speed) ---
+    # We skip Boot and APK installation because they are inside the snapshot.
+    # We only wait for the Daemon to reconnect to the resumed emulator.
+    echo -e "${GREEN}      Snapshot detected. Skipping OS boot and APK install waits.${NC}"
+fi
+
+# We always wait for the Daemon because it's the final bridge to the SDK
 wait_for_log "$AGENT_CONTAINER" "Daemon listening on TCP" "Agent Daemon Connection"
 
+# 3.5 Network Rehydration (Warm Boot Only)
+if [ -n "$SNAPSHOT_PATH" ]; then
+    echo "      Rehydrating Android network connection..."
+    # Toggle airplane mode to force DHCP lease renewal
+    docker exec "$ANDROID_CONTAINER" adb shell cmd connectivity airplane-mode enable
+    sleep 2
+    docker exec "$ANDROID_CONTAINER" adb shell cmd connectivity airplane-mode disable
+    # Wait for internet to come back
+    sleep 3
+fi
+
 # 4. Success
 echo -e "\n${GREEN}[4/4] Environment Ready!${NC}"
 echo -e "${BLUE}=================================================${NC}"