@dyyz1993/agent-browser 0.11.0 → 0.11.2

package/skills/agent-browser/references/mobile-viewer.md

@@ -0,0 +1,188 @@
+# Mobile Remote Control (Viewer Mode)
+
+## Overview
+
+When the agent-browser viewer is opened on a **touch device** (phone, tablet), it automatically enters **mobile mode** with a touch-optimized UI. This is distinct from iOS Simulator mode — it works on ANY phone/tablet browser via the web viewer, requiring no simulator installation.
+
+## Touchpad System
+
+The touchpad occupies the bottom portion of the viewer screen and simulates mouse input on the remote browser:
+
+| Gesture             | Action                               | Visual Feedback                         |
+| ------------------- | ------------------------------------ | --------------------------------------- |
+| Single tap          | Click at virtual cursor position     | Cursor flashes red briefly              |
+| Single finger drag  | Move virtual cursor on remote screen | Cursor follows finger                   |
+| Long press (~800ms) | Enter drag mode (hold mouse down)    | Cursor turns orange, shows "DRAG" badge |
+| Two-finger drag     | Scroll wheel (vertical/horizontal)   | Shows "SCROLL" badge                    |
+| Two-finger release  | Momentum scroll (deceleration)       | Smooth deceleration after release       |
+
+**Implementation details:**
+
+- All touch listeners use `{ passive: false }` + `preventDefault()` to prevent browser gestures
+- Movement uses acceleration curve for natural feel (`computeAcceleration()`)
+- Scroll uses separate wheel acceleration (`computeWheelAccel()`)
+- Cooldown period after two-finger scroll prevents accidental clicks
+- Momentum scroll uses RAF loop with 0.92 decay factor
+
+## Virtual Keyboard Toolbar
+
+Collapsible toolbar at the top of the touchpad area:
+
+| Button      | Key Sent    | Code         |
+| ----------- | ----------- | ------------ |
+| Tab         | Tab         | `Tab`        |
+| Up Arrow    | Arrow Up    | `ArrowUp`    |
+| Left Arrow  | Arrow Left  | `ArrowLeft`  |
+| Down Arrow  | Arrow Down  | `ArrowDown`  |
+| Right Arrow | Arrow Right | `ArrowRight` |
+| Enter       | Enter       | `Enter`      |
+| Backspace   | Backspace   | `Backspace`  |
+| Escape      | Escape      | `Escape`     |
+
+- **Collapsed state** (default): Shows only expand button (+ icon)
+- **Expanded state**: Shows all 8 keys in wrapped layout
+- Tap any key to send immediately to remote browser (no need to switch to keyboard app)
+
+## Text Input (Input Panel)
+
+This is the key innovation for mobile remote control — typing text into remote input fields from your phone.
+
+### Flow Diagram
+
+```
+User taps remote <input> on viewer screen
+        ↓
+Daemon detects focus event via injected listener
+        ↓
+Daemon sends {type: "input_focused", value: "...", ...} to viewer
+        ↓
+Viewer enters INPUT MODE:
+  - Hides virtual cursor
+  - Shows #input-panel at screen bottom
+  - Pre-fills local input field with current value
+  - Sets window._currentTargetSelector for fill targeting
+        ↓
+User types in local input field (with IME if needed)
+        ↓
+Text syncs to remote via {type: "input_fill", text: "...", selector: "..."}
+        ↓
+User taps Send (arrow icon) or presses Enter:
+  - Sends final input_fill + Enter keydown/keyup
+  - Exits input mode
+        ↓
+OR user taps Escape or clicks outside panel:
+  - Sends input_blur_element to remote
+  - Exits input mode, restores touchpad
+```
+
+### IME / CJK Composition Support
+
+Critical for Chinese, Japanese, Korean input methods:
+
+| Event                    | Handling                                                 | Prevents                                    |
+| ------------------------ | -------------------------------------------------------- | ------------------------------------------- |
+| `compositionstart`       | Sets `_fieldComposing = true`                            | Intermediate pinyin sent to remote          |
+| `compositionupdate`      | (ignored while composing)                                | Garbage characters                          |
+| `compositionend`         | Sets `_fieldComposing = false`, double-RAF deferred sync | Partial commits sent early                  |
+| RAF poll (30ms interval) | Skips sync while `_fieldComposing === true`              | Race condition with IME candidate selection |
+
+**Key insight:** Only fully committed characters (after user selects from IME candidate list) are synced to the remote browser. Intermediate pinyin/kana composition is completely filtered out.
+
+### Input Panel Layout
+
+```
+┌─────────────────────────────────────────┐
+│ target: input[type="email"]            │  <- label row
+├─────────────────────────────────────────┤
+│ [________________________] [>]             │  <- input + send button
+└─────────────────────────────────────────┘
+```
+
+- Label shows: input type + placeholder (if different from value)
+- Input field: `border-radius: 18px`, `font-size:16px` (prevents iOS zoom)
+- Send button: Blue circle with arrow SVG icon
+- Dismissal: Tap outside panel or press Escape
+
+### Keyboard Awareness on Mobile
+
+On mobile devices, the viewer intentionally suppresses keyboard-related events to prevent interference:
+
+- `hiddenInput` (#hidden-input) is **NOT created** on touch devices (unlike desktop mode)
+- Document-level `keydown`/`keyup` listeners check `event.target` — ignores events from `#input-field`
+- This allows the native mobile keyboard to work normally for text input without conflicting with remote keyboard forwarding
+
+## DeviceMode Dynamic Switching
+
+The viewer does NOT detect device type once at startup. It uses a reactive architecture that can switch at runtime:
+
+### Detection Function
+
+```javascript
+function detectDeviceMode() {
+  var uaMatch = /iphone|ipod|android(?=.*mobile)|mobile|tablet|ipad/i.test(ua);
+  var hasTouch = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
+  return uaMatch || hasTouch ? 'mobile' : 'desktop';
+}
+```
+
+### Singleton Architecture
+
+```javascript
+const DeviceMode = {
+  _current: detectDeviceMode(), // Initial detection
+  _listeners: [], // Change callbacks
+
+  get current() {
+    return this._current;
+  },
+
+  onModeChange(fn) {
+    this._listeners.push(fn);
+  },
+
+  switchTo(mode) {
+    if (mode === this._current) return; // No-op for same mode
+    var prev = this._current;
+    this._current = mode;
+    if (mode === 'desktop') {
+      MobileModule.detach(); // Hide touchpad, show cursor
+      DesktopModule.attach(); // Create hiddenInput, focus it
+    } else {
+      DesktopModule.detach(); // Remove hiddenInput
+      MobileModule.attach(); // Show touchpad, init cursor
+    }
+    this._listeners.forEach((fn) => fn(mode, prev));
+  },
+};
+```
+
+### Module Lifecycle
+
+**DesktopModule** (PC mode):
+
+- `attach()`: Creates invisible `#hidden-input`, focuses it (captures keyboard for remote forwarding)
+- `detach()`: Blurs and removes hiddenInput
+
+**MobileModule** (touch mode):
+
+- `attach()`: Shows touchpad (display:flex), initializes virtual cursor, sets up toolbar
+- `detach()`: Hides input-panel, shows cursor again
+
+### Auto-Switching Triggers
+
+| Trigger                                 | Handler                   | Use Case                                          |
+| --------------------------------------- | ------------------------- | ------------------------------------------------- |
+| `resize` event                          | Debounced 100ms re-detect | Phone rotation, window resize                     |
+| `orientationchange`                     | Delayed 200ms re-detect   | Portrait<->Landscape                              |
+| `matchMedia("(pointer:coarse)")` change | Immediate switch          | Stylus connect/disconnect, tablet keyboard attach |
+
+## Mobile-Specific CSS Considerations
+
+| Issue                                  | Solution                                                  |
+| -------------------------------------- | --------------------------------------------------------- |
+| iOS keyboard pushes content up         | `min/max-height: 100dvh` on html/body, `position: fixed`  |
+| VisualViewport API for keyboard height | Listener resizes input panel above keyboard               |
+| iOS auto-scroll during input           | `setInterval` scroll guard (100ms) fights browser scroll  |
+| Browser gesture conflicts              | `touch-action: none` on body during input mode            |
+| Safe area (notch phones)               | `padding-bottom: env(safe-area-inset-bottom)` on touchpad |
+| Small tap targets                      | Minimum 44px height on buttons (iOS guideline)            |

package/skills/agent-browser/references/viewer-mode.md

@@ -0,0 +1,148 @@
+# Viewer / Streaming Mode
+
+## Overview
+
+The viewer mode provides a **real-time visual remote browser interface**. It streams browser frames (JPEG/WebP) over WebSocket and forwards user input (mouse, keyboard, touch) back to the daemon. This enables:
+
+- **Remote debugging** — see what the browser sees in real time
+- **Mobile device control** — operate a desktop browser from your phone
+- **Presentation/demo** — show browser activity to an audience
+- **Collaboration** — share a browser session with others
+
+## Starting the Viewer
+
+```bash
+# Prerequisite: have a browser session running
+agent-browser open https://example.com
+
+# Start viewer (opens URL in default browser)
+agent-browser viewer
+
+# Get connection details as JSON (for scripting/embedding)
+agent-browser viewer --json
+# Output: {"url":"http://localhost:5005/view?session=default","ws":"ws://...","port":5005}
+```
+
+## Viewer URL Parameters
+
+| Parameter          | Description                            |
+| ------------------ | -------------------------------------- |
+| `?session=<id>`    | Connect to a specific named session    |
+| `?instanceId=<id>` | Connect to a specific browser instance |
+
+## Architecture
+
+```
+┌─────────────┐    IPC     ┌───────────────────┐   WebSocket   ┌──────────┐
+│  Browser    │ ───────→ │  Daemon Process   │ ←────────────→ │  Viewer  │
+│  (Playwright) │           │  (:5000 socket)   │               │  (Browser) │
+└─────────────┘           └────────┬─────────┘               └──────────┘
+                             │
+                    standalone HTTP+WS server (:5005)
+                    serves viewer.html + proxies messages
+```
+
+**Data flow:**
+
+1. **Frames**: Browser -> Daemon -> Standalone Server -> Viewer (binary JPEG/WebP via WS)
+2. **Input**: Viewer -> Standalone Server -> Daemon -> Browser (JSON messages)
+
+## Viewer Page Features
+
+### Desktop Mode (PC/Mac)
+
+| Feature      | Description                                                         |
+| ------------ | ------------------------------------------------------------------- |
+| Screen area  | Shows streamed frame, click/drag/scroll sends input to remote       |
+| Toolbar      | URL bar, connection status, quality badge, record button            |
+| Hidden input | Invisible capture field for keyboard events (auto-focused on click) |
+| Cursor       | Red dot showing remote mouse position                               |
+
+### Mobile Mode (Touch Device)
+
+Automatically activates on touch devices. See [mobile-viewer.md](mobile-viewer.md) for full details.
+
+| Feature          | Description                                         |
+| ---------------- | --------------------------------------------------- |
+| Touchpad         | Bottom gesture area for cursor simulation           |
+| Input Panel      | Text input popup when tapping remote input fields   |
+| Keyboard toolbar | Virtual keys: Tab, Arrows, Enter, Backspace, Escape |
+| IME support      | Chinese/Japanese composition (pinyin, kana, etc.)   |
+
+## Element Selector / Crop Mode
+
+Crop the video stream to a specific DOM element's bounds:
+
+```bash
+# Via viewer UI: click element selector button, then click target element
+# The stream is cropped to that element's rectangle
+```
+
+When element mode is active:
+
+- Server crops frames to element bounds using Sharp
+- Mouse coordinates auto-map to element-local space
+- Falls back to "degraded mode" (full page) if element not found or disappears
+- `deviceWidth`/`deviceHeight` in metadata reflect element dimensions
+
+Use cases:
+
+- Focus testing on a specific component
+- Recording interactions within a widget
+- Bandwidth savings (only stream the element, not full page)
+
+## Message Types (Viewer <-> Server)
+
+### Server → Viewer (over WebSocket)
+
+| Type            | Purpose                                                            |
+| --------------- | ------------------------------------------------------------------ |
+| `frame`         | Binary frame data with metadata (dimensions, format, element info) |
+| `status`        | Connection status, viewport changes                                |
+| `navigation`    | URL/title changes                                                  |
+| `input_focused` | Remote element received focus → triggers input panel (mobile)      |
+| `input_value`   | Remote input value changed                                         |
+| `input_blur`    | Remote element lost focus                                          |
+
+### Viewer → Server (over WebSocket)
+
+| Type                   | Purpose                                             |
+| ---------------------- | --------------------------------------------------- |
+| `input_mouse`          | Mouse move/press/release/wheel                      |
+| `input_keyboard`       | Key down/up with modifiers                          |
+| `input_fill`           | Full text value sync (mobile input panel)           |
+| `input_blur_element`   | Blur remote element (mobile input commit)           |
+| `keyboard_insert_text` | Character-by-character insert (desktop hiddenInput) |
+| `user_activity`        | Keep-alive signal (resumes streaming if paused)     |
+| `selector_element`     | Request crop to specific element                    |
+
+## Troubleshooting
+
+### Black screen
+
+- Check daemon is running: `agent-browser status`
+- Verify browser launched: `agent-browser open https://example.com` should work first
+
+### Connection refused
+
+- The viewer command auto-starts the standalone server on port 5005
+- If port conflicts, check: `lsof -i :5005`
+- Kill stale process: `kill $(lsof -t -i :5005)`
+
+### Laggy updates
+
+- Frame compression is JPEG by default (adjustable)
+- Quality badge shows current state: "interacting" / "static" / "compressed"
+- Network latency between viewer and server affects frame rate
+
+### Element not found (degraded mode)
+
+- Yellow toast appears: "Element not found, showing full page"
+- Element may have been removed by SPA navigation or animation
+- Re-select the element or exit selector mode
+
+### Viewer shows but no frame
+
+- Check daemon log: `~/.agent-browser/default.log`
+- Look for "Browser not launched" errors
+- Ensure `agent-browser open` was called before `agent-browser viewer`

package/skills/agent-browser/templates/api-interception.sh

@@ -1,5 +1,6 @@
 #!/bin/bash
 # API Interception Template - Passively capture API responses
+set -euo pipefail
 # Usage: ./api-interception.sh [target_url] [output_file]
 
 TARGET_URL="${1:-https://example.com/user/profile}"
@@ -12,7 +13,8 @@ sleep 1
 
 echo ""
 echo "=== 2. Open blank page ==="
-export https_proxy=http://127.0.0.1:7890
+# Optional: set PROXY_URL if using a proxy
+export https_proxy=${PROXY_URL:-}
 agent-browser open "about:blank"
 sleep 1
 

package/skills/agent-browser/templates/data-extraction.sh

@@ -34,7 +34,8 @@ case "$MODE" in
   api)
     echo ""
     echo "=== 2. API Interception Mode ==="
-    export https_proxy=http://127.0.0.1:7890
+    # Optional: set PROXY_URL if using a proxy
+export https_proxy=${PROXY_URL:-}
     agent-browser open "about:blank"
     sleep 1
     
@@ -64,7 +65,8 @@ case "$MODE" in
   scroll)
     echo ""
     echo "=== 2. Infinite Scroll Mode ==="
-    export https_proxy=http://127.0.0.1:7890
+    # Optional: set PROXY_URL if using a proxy
+export https_proxy=${PROXY_URL:-}
     agent-browser open "$TARGET_URL"
     sleep 2
     
@@ -125,7 +127,8 @@ print(json.dumps(unique, ensure_ascii=False))
   js)
     echo ""
     echo "=== 2. JS Variable Extraction Mode ==="
-    export https_proxy=http://127.0.0.1:7890
+    # Optional: set PROXY_URL if using a proxy
+export https_proxy=${PROXY_URL:-}
     agent-browser open "$TARGET_URL"
     sleep 3
     
@@ -153,7 +156,8 @@ print(json.dumps(unique, ensure_ascii=False))
   dom|*)
     echo ""
     echo "=== 2. DOM Extraction Mode ==="
-    export https_proxy=http://127.0.0.1:7890
+    # Optional: set PROXY_URL if using a proxy
+export https_proxy=${PROXY_URL:-}
     agent-browser open "$TARGET_URL"
     sleep 2
     

package/skills/agent-browser/templates/form-automation.sh

@@ -1,32 +1,27 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Template: Form Automation Workflow
 # Purpose: Fill and submit web forms with validation
 # Usage: ./form-automation.sh <form-url>
 #
-# This template demonstrates the snapshot-interact-verify pattern:
-# 1. Navigate to form
-# 2. Snapshot to get element refs
-# 3. Fill fields using refs
-# 4. Submit and verify result
-#
-# Customize: Update the refs (@e1, @e2, etc.) based on your form's snapshot output
+# Demonstrates: snapshot -> interact -> verify pattern
 
 set -euo pipefail
 
 FORM_URL="${1:?Usage: $0 <form-url>}"
+SESSION="form-$(date +%s)"
 
-echo "Form automation: $FORM_URL"
+echo "=== Form Automation: $FORM_URL ==="
 
 # Step 1: Navigate to form
-agent-browser open "$FORM_URL"
-agent-browser wait --load networkidle
+agent-browser --session "$SESSION" open "$FORM_URL"
+agent-browser --session "$SESSION" wait --load networkidle
 
 # Step 2: Snapshot to discover form elements
 echo ""
 echo "Form structure:"
-agent-browser snapshot -i
+agent-browser --session "$SESSION" snapshot -i
 
-# Step 3: Fill form fields (customize these refs based on snapshot output)
+# Step 3: Fill form fields (customize refs based on snapshot output above)
 #
 # Common field types:
 #   agent-browser fill @e1 "John Doe"           # Text input
@@ -34,27 +29,27 @@ agent-browser snapshot -i
 #   agent-browser fill @e3 "SecureP@ss123"      # Password input
 #   agent-browser select @e4 "Option Value"     # Dropdown
 #   agent-browser check @e5                     # Checkbox
-#   agent-browser click @e6                     # Radio button
+#   agent-browser click @e6                     # Radio button / Submit button
 #   agent-browser fill @e7 "Multi-line text"   # Textarea
 #   agent-browser upload @e8 /path/to/file.pdf # File upload
 #
 # Uncomment and modify:
-# agent-browser fill @e1 "Test User"
-# agent-browser fill @e2 "test@example.com"
-# agent-browser click @e3  # Submit button
+# agent-browser --session "$SESSION" fill @e1 "Test User"
+# agent-browser --session "$SESSION" fill @e2 "test@example.com"
+# agent-browser --session "$SESSION" click @e3  # Submit button
 
-# Step 4: Wait for submission
-# agent-browser wait --load networkidle
-# agent-browser wait --url "**/success"  # Or wait for redirect
+# Step 4: Wait for submission to complete
+agent-browser --session "$SESSION" wait --load networkidle
+# agent-browser --session "$SESSION" wait --url "**/success"  # Or wait for redirect
 
 # Step 5: Verify result
 echo ""
 echo "Result:"
-agent-browser get url
-agent-browser snapshot -i
+agent-browser --session "$SESSION" get url
+agent-browser --session "$SESSION" snapshot -i
 
 # Optional: Capture evidence
-agent-browser screenshot /tmp/form-result.png
+agent-browser --session "$SESSION" screenshot /tmp/form-result.png
 echo "Screenshot saved: /tmp/form-result.png"
 
 # Cleanup

package/skills/agent-browser/templates/network-intercept-crawl.sh

@@ -1,5 +1,6 @@
 #!/bin/bash
 # Network Interception Data Collection Template
+set -euo pipefail
 # Usage: ./network-intercept-crawl.sh <url> <output-dir> [max-scrolls]
 #
 # This script demonstrates how to capture API data using network interception.

package/skills/agent-browser/templates/recorder-workflow.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+# Template: Recorder Workflow
+# Purpose: Record browser actions, save as YAML, replay later
+# Usage: ./recorder-workflow.sh [url] [output.yaml]
+#
+# Records your interactions into a replayable YAML workflow file.
+# Useful for test automation, demo creation, and regression testing.
+
+set -euo pipefail
+
+URL="${1:?https://example.com/form}"
+OUTPUT="${2:-recording-$(date +%Y%m%d-%H%M%S).yaml}"
+SESSION="record-$(date +%s)"
+
+echo "=== Recorder Workflow: $URL ==="
+
+# Step 1: Start recording
+agent-browser recorder start --session "$SESSION"
+echo "Recording started on session: $SESSION"
+
+# Step 2: Navigate and perform workflow
+agent-browser --session "$SESSION" open "$URL"
+agent-browser --session "$SESSION" wait --load networkidle
+
+echo ""
+echo "Form structure (copy refs from below):"
+agent-browser --session "$SESSION" snapshot -i
+
+# Step 3: Perform your actions here (uncomment/customize):
+#
+# agent-browser --session "$SESSION" fill @e1 "user@example.com"
+# agent-browser --session "$SESSION" fill @e2 "password123"
+# agent-browser --session "$SESSION" click @e3
+# agent-browser --session "$SESSION" wait --load networkidle
+# agent-browser --session "$SESSION" snapshot -i  # Verify
+
+echo ""
+echo "Waiting ${TIMEOUT:-10}s before stopping recording..."
+sleep "${TIMEOUT:-10}"
+
+# Step 4: Stop recording and save
+agent-browser recorder stop --session "$SESSION" --output "$OUTPUT"
+echo ""
+echo "Saved recording to: $OUTPUT"
+echo ""
+echo "To replay:"
+echo "  agent-browser recorder replay $OUTPUT"
+
+# Cleanup
+agent-browser --session "$SESSION" close
+echo "Done"

package/skills/agent-browser/templates/viewer-remote.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Template: Viewer Remote Control Workflow
+# Purpose: Open browser, start viewer, interact remotely via streaming UI
+# Usage: ./viewer-remote.sh [url] [timeout-seconds]
+#
+# The viewer streams real-time browser frames to your local browser.
+# On touch devices, you get touchpad + input panel for mobile control.
+
+set -euo pipefail
+
+URL="${1:?https://www.baidu.com}"
+TIMEOUT="${2:-300}"
+SESSION="viewer-$(date +%s)"
+
+echo "=== Viewer Remote Control: $URL ==="
+
+# Step 1: Launch browser (headed so you can see it locally too)
+agent-browser --session "$SESSION" --headed open "$URL"
+agent-browser --session "$SESSION" wait --load networkidle
+
+# Step 2: Start viewer and get connection URL
+VIEWER_INFO=$(agent-browser --session "$SESSION" viewer --json)
+echo "Viewer info: $VIEWER_INFO"
+
+# Extract URL (requires jq)
+VIEWER_URL=$(echo "$VIEWER_INFO" | jq -r '.url // 2>/dev/null || echo "Check port 5005 manually")
+echo ""
+echo "Open this URL in your browser:"
+echo "  $VIEWER_URL"
+echo ""
+echo "Tips:"
+echo "  - Desktop: Click/drag/scroll on the streamed screen area"
+echo "  - Mobile: Use touchpad at bottom for cursor, tap inputs for text panel"
+echo "  - Tap a remote input field to open mobile text input"
+echo ""
+echo "Viewer will auto-close after ${TIMEOUT}s..."
+sleep "$TIMEOUT"
+
+# Cleanup
+agent-browser --session "$SESSION" close
+echo "Done"

package/scripts/check_goods_container.js

@@ -1,35 +0,0 @@
-(() => {
-  const result = {
-    goodsContainerCount: 0,
-    sampleContainer: null,
-    allClasses: []
-  };
-  
-  const containers = document.querySelectorAll('._goodsContainer_1p2ae_1');
-  result.goodsContainerCount = containers.length;
-  
-  if (containers.length > 0) {
-    result.sampleContainer = {
-      className: containers[0].className,
-      innerHTML: containers[0].innerHTML.substring(0, 500),
-      text: containers[0].textContent?.substring(0, 200)
-    };
-  }
-  
-  const allDivs = document.querySelectorAll('div');
-  const classSet = new Set();
-  allDivs.forEach(div => {
-    if (div.className) {
-      const classes = String(div.className).split(' ');
-      classes.forEach(c => {
-        if (c.includes('goods') || c.includes('item') || c.includes('product')) {
-          classSet.add(c);
-        }
-      });
-    }
-  });
-  
-  result.allClasses = Array.from(classSet).slice(0, 20);
-  
-  return result;
-})()

package/scripts/check_page_content.js

@@ -1,36 +0,0 @@
-(() => {
-  const result = {
-    visibleElements: [],
-    linksWithProductInClass: []
-  };
-  
-  const allElements = document.querySelectorAll('*');
-  let count = 0;
-  
-  for (const el of allElements) {
-    if (count >= 50) break;
-    
-    const className = el.className ? String(el.className) : '';
-    const text = el.textContent?.trim() || '';
-    
-    if ((className.includes('product') || className.includes('item') || className.includes('card')) && text.length > 10) {
-      result.visibleElements.push({
-        tagName: el.tagName,
-        className: className.substring(0, 100),
-        text: text.substring(0, 100)
-      });
-      count++;
-    }
-  }
-  
-  const productLinks = document.querySelectorAll('a[href*="item.jd"], a[href*="product.jd"]');
-  productLinks.forEach((link, index) => {
-    if (index >= 10) return;
-    result.linksWithProductInClass.push({
-      href: link.href.substring(0, 100),
-      text: link.textContent?.substring(0, 50)
-    });
-  });
-  
-  return result;
-})()

package/scripts/click_applause_rate.js

@@ -1,30 +0,0 @@
-(async () => {
-  const applauseRateEl = document.querySelector('.applause-rate');
-  
-  if (applauseRateEl) {
-    applauseRateEl.click();
-    
-    await new Promise(resolve => setTimeout(resolve, 3000));
-    
-    const result = {
-      elementFound: true,
-      elementText: applauseRateEl.textContent,
-      popup: null
-    };
-    
-    const popup = document.querySelector('[class*="popup"], [class*="modal"], [class*="dialog"]');
-    if (popup) {
-      result.popup = {
-        className: popup.className,
-        text: popup.textContent?.substring(0, 500)
-      };
-    }
-    
-    return result;
-  } else {
-    return {
-      elementFound: false,
-      message: 'applause-rate element not found'
-    };
-  }
-})()