@kritchoff/agent-browser 0.9.43 → 0.9.46

package/docker-compose.sdk.yml

@@ -3,7 +3,7 @@ services:
   # Android Emulator Service (The "Body")
   # ---------------------------------------------------------------------------
   android-service:
-    image: kritchoff/agent-android:v1.0.7
+    image: kritchoff/agent-android:v1.0.8
     platform: linux/amd64
     privileged: true # Required for KVM
     restart: always  # Auto-restart on crash
@@ -19,18 +19,21 @@ 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
       timeout: 5s
       retries: 60
       start_period: 60s
+    networks:
+      - agent-network
 
   # ---------------------------------------------------------------------------
   # Agent Browser Service (The "Brain")
   # ---------------------------------------------------------------------------
   agent-service:
-    image: kritchoff/agent-daemon:v1.0.7
+    image: kritchoff/agent-daemon:v1.0.8
     platform: linux/amd64
     restart: always
     depends_on:
@@ -40,8 +43,12 @@ services:
     environment:
       - AGENT_DEBUG=false
       - AGENT_BROWSER_SOCKET_DIR=/tmp/agent-browser
-    links:
-      - android-service
+    networks:
+      - agent-network
 
 volumes:
   avd-data:
+
+networks:
+  agent-network:
+    driver: bridge

package/package.json

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

package/scripts/start-android-agent.sh

@@ -6,19 +6,18 @@ mkdir -p $AGENT_BROWSER_SOCKET_DIR
 
 echo "[Agent] Starting Agent Browser Service"
 
-# Resolve IP of android-service to avoid Chrome Host header security block
-echo "[Agent] Resolving android-service IP..."
+# Resolve IP of android-service via Docker's built-in DNS
+echo "[Agent] Resolving android-service IP via DNS..."
 ANDROID_IP=""
 until [ -n "$ANDROID_IP" ]; do
-  # Try /etc/hosts (Fastest, reliable with Docker links)
-  ANDROID_IP=$(grep "android-service" /etc/hosts | awk '{print $1}' | head -n 1)
+  ANDROID_IP=$(node -e 'require("dns").lookup("android-service", (err, addr) => { if(!err) console.log(addr) })' 2>/dev/null)
   
   if [ -z "$ANDROID_IP" ]; then
-    echo "[Agent] Waiting for DNS resolution..."
+    echo "[Agent] Waiting for Docker DNS resolution of 'android-service'..."
     sleep 2
   fi
 done
-echo "[Agent] Android IP: $ANDROID_IP"
+echo "[Agent] Resolved Android IP: $ANDROID_IP"
 
 # Wait for CDP Bridge (Port 9224)
 echo "[Agent] Waiting for Android CDP at http://$ANDROID_IP:9224..."

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,69 @@ 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"
+        log_success "Found cached baseline snapshot. Performing HYPER-SPEED WARM BOOT..."
+        export EMULATOR_SNAPSHOT_NAME="quickboot"
+        "$SDK_ROOT/start.sh"
         
-                # 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
+        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
+            sleep 5
+            "$SDK_ROOT/start.sh"
+        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."
+
+        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)
+        AGENT_CONT=$(docker compose ps -q agent-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
+
+        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
+            sleep 5
+            "$SDK_ROOT/start.sh"
+            CONTAINER=$(docker compose ps -q android-service)
+        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 +165,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 +190,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}"
 
@@ -107,6 +75,17 @@ wait_for_log "$ANDROID_CONTAINER" "CDP Bridge ready" "CDP Bridge"
 # Daemon logs "Daemon listening on TCP 0.0.0.0:3000" in direct mode
 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}"