@dyyz1993/agent-browser 0.9.2

package/scripts/find_root_content.js

@@ -0,0 +1,26 @@
+(() => {
+  const root = document.getElementById('root');
+  
+  if (!root) {
+    return { error: 'root not found' };
+  }
+  
+  const result = {
+    rootId: root.id,
+    childrenCount: root.children.length,
+    children: []
+  };
+  
+  for (let i = 0; i < Math.min(root.children.length, 20); i++) {
+    const child = root.children[i];
+    result.children.push({
+      index: i,
+      tagName: child.tagName,
+      id: child.id,
+      className: child.className,
+      innerHTML: child.innerHTML.substring(0, 300)
+    });
+  }
+  
+  return result;
+})()

package/scripts/find_unique_products.js

@@ -0,0 +1,55 @@
+(async () => {
+  const result = {
+    products: []
+  };
+  
+  const containers = document.querySelectorAll('._goodsContainer_1p2ae_1');
+  
+  containers.forEach((container, index) => {
+    if (index >= 10) return;
+    
+    const product = {
+      index,
+      className: container.className,
+      text: container.textContent?.trim().substring(0, 300)
+    };
+    
+    const link = container.querySelector('a[href*="jd"]');
+    if (link) {
+      product.link = link.href;
+    }
+    
+    const img = container.querySelector('img');
+    if (img) {
+      product.img = img.getAttribute('data-src')?.substring(0, 100) || img.src?.substring(0, 100);
+    }
+    
+    const text = container.textContent || '';
+    
+    const priceMatch = text.match(/[¥￥]\s*\d+\.?\d*/);
+    if (priceMatch) {
+      product.price = priceMatch[0];
+    }
+    
+    const salesMatch = text.match(/已售[\d\+万]+/);
+    if (salesMatch) {
+      product.sales = salesMatch[0];
+    }
+    
+    const shopMatch = text.match(/([^\s]+旗舰店|[^\s]+专营店)/);
+    if (shopMatch) {
+      product.shop = shopMatch[0];
+    }
+    
+    const titleMatch = text.match(/([^\s]{5,50})/);
+    if (titleMatch && !titleMatch[0].includes('广告') && !titleMatch[0].includes('旗舰店')) {
+      product.title = titleMatch[0];
+    }
+    
+    if (product.price || product.shop || product.sales) {
+      result.products.push(product);
+    }
+  });
+  
+  return result;
+})()

package/scripts/get_jd_product_detail.js

@@ -0,0 +1,16 @@
+(() => {
+  const reviews = {};
+  
+  const goodEl = document.querySelector('.filter-items a[data-tab="good"]');
+  const neutralEl = document.querySelector('.filter-items a[data-tab="neutral"]');
+  const badEl = document.querySelector('.filter-items a[data-tab="bad"]');
+  
+  reviews.good = goodEl?.textContent?.trim() || '';
+  reviews.neutral = neutralEl?.textContent?.trim() || '';
+  reviews.bad = badEl?.textContent?.trim() || '';
+  
+  const regionEl = document.querySelector('.address-item');
+  const region = regionEl?.textContent?.trim() || '';
+  
+  return { reviews, region };
+})()

package/scripts/get_jd_products.js

@@ -0,0 +1,23 @@
+(() => {
+  const items = document.querySelectorAll('.gl-item');
+  const products = [];
+  
+  items.forEach((item, index) => {
+    const titleEl = item.querySelector('.p-name a');
+    const priceEl = item.querySelector('.p-price');
+    const shopEl = item.querySelector('.p-shop a');
+    const salesEl = item.querySelector('.p-commit');
+    const linkEl = item.querySelector('.p-name a');
+    
+    products.push({
+      index: index,
+      title: titleEl?.textContent?.trim() || '',
+      price: priceEl?.textContent?.trim() || '',
+      shop: shopEl?.textContent?.trim() || '',
+      sales: salesEl?.textContent?.trim() || '',
+      link: linkEl?.href || ''
+    });
+  });
+  
+  return products.slice(0, 10);
+})()

package/scripts/get_jd_seafood_products.js

@@ -0,0 +1,44 @@
+(async () => {
+  const result = {
+    products: []
+  };
+  
+  window.scrollTo(0, 1000);
+  await new Promise(resolve => setTimeout(resolve, 3000));
+  
+  window.scrollTo(0, 3000);
+  await new Promise(resolve => setTimeout(resolve, 3000));
+  
+  const productCards = document.querySelectorAll('[data-point-id], .youLikeItem, [class*="item"]');
+  
+  productCards.forEach((card, index) => {
+    if (index >= 15) return;
+    
+    const product = {
+      index,
+      className: card.className,
+      title: '',
+      price: '',
+      shop: '',
+      link: ''
+    };
+    
+    const titleEl = card.querySelector('[class*="title"], [class*="name"], h3, h4, h5');
+    const priceEl = card.querySelector('[class*="price"], .price');
+    const shopEl = card.querySelector('[class*="shop"], [class*="store"], [class*="brand"]');
+    const linkEl = card.querySelector('a[href*="jd"]');
+    const imgEl = card.querySelector('img');
+    
+    if (titleEl) product.title = titleEl.textContent?.trim() || '';
+    if (priceEl) product.price = priceEl.textContent?.trim() || '';
+    if (shopEl) product.shop = shopEl.textContent?.trim() || '';
+    if (linkEl) product.link = linkEl.href || '';
+    if (imgEl && imgEl.src) product.image = imgEl.src.substring(0, 100);
+    
+    if (product.title || product.price || product.link) {
+      result.products.push(product);
+    }
+  });
+  
+  return result;
+})()

package/scripts/get_product_details_from_images.js

@@ -0,0 +1,54 @@
+(async () => {
+  const result = {
+    products: []
+  };
+  
+  const wrappers = document.querySelectorAll('._wrapper_8g5fc_1');
+  
+  wrappers.forEach((wrapper, index) => {
+    if (index >= 10) return;
+    
+    const product = {
+      index,
+      className: wrapper.className
+    };
+    
+    const img = wrapper.querySelector('img');
+    if (img) {
+      product.img = img.getAttribute('data-src')?.substring(0, 100) || img.src?.substring(0, 100);
+    }
+    
+    const parentLink = wrapper.closest('a');
+    if (parentLink) {
+      product.link = parentLink.href;
+    }
+    
+    const allText = wrapper.textContent?.trim() || '';
+    product.text = allText.substring(0, 150);
+    
+    const priceElements = wrapper.querySelectorAll('*');
+    for (const el of priceElements) {
+      const text = el.textContent?.trim() || '';
+      if (text.match(/[¥￥]\s*\d+/)) {
+        product.price = text;
+        break;
+      }
+    }
+    
+    const greatGrandParent = wrapper.parentElement?.parentElement?.parentElement;
+    if (greatGrandParent) {
+      product.greatGrandParentClass = greatGrandParent.className?.substring(0, 100);
+      const greatGrandParentText = greatGrandParent.textContent?.trim() || '';
+      product.greatGrandParentText = greatGrandParentText.substring(0, 200);
+      
+      const greatGrandParentLink = greatGrandParent.querySelector('a[href*="jd"]');
+      if (greatGrandParentLink) {
+        product.link = greatGrandParentLink.href;
+      }
+    }
+    
+    result.products.push(product);
+  });
+  
+  return result;
+})()

package/scripts/postinstall.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for agent-browser
+ * 
+ * Downloads the platform-specific native binary if not present.
+ * On global installs, patches npm's bin entry to use the native binary directly:
+ * - Windows: Overwrites .cmd/.ps1 shims
+ * - Mac/Linux: Replaces symlink to point to native binary
+ */
+
+import { existsSync, mkdirSync, chmodSync, createWriteStream, unlinkSync, writeFileSync, symlinkSync, lstatSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { platform, arch } from 'os';
+import { get } from 'https';
+import { execSync } from 'child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = join(__dirname, '..');
+const binDir = join(projectRoot, 'bin');
+
+// Platform detection
+const platformKey = `${platform()}-${arch()}`;
+const ext = platform() === 'win32' ? '.exe' : '';
+const binaryName = `agent-browser-${platformKey}${ext}`;
+const binaryPath = join(binDir, binaryName);
+
+// Package info
+const packageJson = JSON.parse(
+  (await import('fs')).readFileSync(join(projectRoot, 'package.json'), 'utf8')
+);
+const version = packageJson.version;
+
+// GitHub release URL
+const GITHUB_REPO = 'vercel-labs/agent-browser';
+const DOWNLOAD_URL = `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${binaryName}`;
+
+async function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = createWriteStream(dest);
+    
+    const request = (url) => {
+      get(url, (response) => {
+        // Handle redirects
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          request(response.headers.location);
+          return;
+        }
+        
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
+          return;
+        }
+        
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          resolve();
+        });
+      }).on('error', (err) => {
+        unlinkSync(dest);
+        reject(err);
+      });
+    };
+    
+    request(url);
+  });
+}
+
+async function main() {
+  // Check if binary already exists
+  if (existsSync(binaryPath)) {
+    // Ensure binary is executable (npm doesn't preserve execute bit)
+    if (platform() !== 'win32') {
+      chmodSync(binaryPath, 0o755);
+    }
+    console.log(`✓ Native binary ready: ${binaryName}`);
+    
+    // On global installs, fix npm's bin entry to use native binary directly
+    await fixGlobalInstallBin();
+    
+    showPlaywrightReminder();
+    return;
+  }
+
+  // Ensure bin directory exists
+  if (!existsSync(binDir)) {
+    mkdirSync(binDir, { recursive: true });
+  }
+
+  console.log(`Downloading native binary for ${platformKey}...`);
+  console.log(`URL: ${DOWNLOAD_URL}`);
+
+  try {
+    await downloadFile(DOWNLOAD_URL, binaryPath);
+    
+    // Make executable on Unix
+    if (platform() !== 'win32') {
+      chmodSync(binaryPath, 0o755);
+    }
+    
+    console.log(`✓ Downloaded native binary: ${binaryName}`);
+  } catch (err) {
+    console.log(`⚠ Could not download native binary: ${err.message}`);
+    console.log(`  The CLI will use Node.js fallback (slightly slower startup)`);
+    console.log('');
+    console.log('To build the native binary locally:');
+    console.log('  1. Install Rust: https://rustup.rs');
+    console.log('  2. Run: npm run build:native');
+  }
+
+  // On global installs, fix npm's bin entry to use native binary directly
+  // This avoids the /bin/sh error on Windows and provides zero-overhead execution
+  await fixGlobalInstallBin();
+
+  showPlaywrightReminder();
+}
+
+function showPlaywrightReminder() {
+  console.log('');
+  console.log('╔═══════════════════════════════════════════════════════════════════════════╗');
+  console.log('║ To download browser binaries, run:                                        ║');
+  console.log('║                                                                           ║');
+  console.log('║     npx playwright install chromium                                       ║');
+  console.log('║                                                                           ║');
+  console.log('║ On Linux, include system dependencies with:                               ║');
+  console.log('║                                                                           ║');
+  console.log('║     npx playwright install --with-deps chromium                           ║');
+  console.log('║                                                                           ║');
+  console.log('╚═══════════════════════════════════════════════════════════════════════════╝');
+}
+
+/**
+ * Fix npm's bin entry on global installs to use the native binary directly.
+ * This provides zero-overhead CLI execution for global installs.
+ */
+async function fixGlobalInstallBin() {
+  if (platform() === 'win32') {
+    await fixWindowsShims();
+  } else {
+    await fixUnixSymlink();
+  }
+}
+
+/**
+ * Fix npm symlink on Mac/Linux global installs.
+ * Replace the symlink to the JS wrapper with a symlink to the native binary.
+ */
+async function fixUnixSymlink() {
+  // Get npm's global bin directory (npm prefix -g + /bin)
+  let npmBinDir;
+  try {
+    const prefix = execSync('npm prefix -g', { encoding: 'utf8' }).trim();
+    npmBinDir = join(prefix, 'bin');
+  } catch {
+    return; // npm not available
+  }
+
+  const symlinkPath = join(npmBinDir, 'agent-browser');
+
+  // Check if symlink exists (indicates global install)
+  try {
+    const stat = lstatSync(symlinkPath);
+    if (!stat.isSymbolicLink()) {
+      return; // Not a symlink, don't touch it
+    }
+  } catch {
+    return; // Symlink doesn't exist, not a global install
+  }
+
+  // Replace symlink to point directly to native binary
+  try {
+    unlinkSync(symlinkPath);
+    symlinkSync(binaryPath, symlinkPath);
+    console.log('✓ Optimized: symlink points to native binary (zero overhead)');
+  } catch (err) {
+    // Permission error or other issue - not critical, JS wrapper still works
+    console.log(`⚠ Could not optimize symlink: ${err.message}`);
+    console.log('  CLI will work via Node.js wrapper (slightly slower startup)');
+  }
+}
+
+/**
+ * Fix npm-generated shims on Windows global installs.
+ * npm generates shims that try to run /bin/sh, which doesn't exist on Windows.
+ * We overwrite them to invoke the native .exe directly.
+ */
+async function fixWindowsShims() {
+  // Check if this is a global install by looking for npm's global prefix
+  let npmBinDir;
+  try {
+    npmBinDir = execSync('npm prefix -g', { encoding: 'utf8' }).trim();
+  } catch {
+    return; // Not a global install or npm not available
+  }
+
+  // The shims are in the npm prefix directory (not prefix/bin on Windows)
+  const cmdShim = join(npmBinDir, 'agent-browser.cmd');
+  const ps1Shim = join(npmBinDir, 'agent-browser.ps1');
+
+  // Only fix if shims exist (indicates global install)
+  if (!existsSync(cmdShim)) {
+    return;
+  }
+
+  // Path to native binary relative to npm prefix
+  const relativeBinaryPath = 'node_modules\\agent-browser\\bin\\agent-browser-win32-x64.exe';
+
+  try {
+    // Overwrite .cmd shim
+    const cmdContent = `@ECHO off\r\n"%~dp0${relativeBinaryPath}" %*\r\n`;
+    writeFileSync(cmdShim, cmdContent);
+
+    // Overwrite .ps1 shim
+    const ps1Content = `#!/usr/bin/env pwsh
+$basedir = Split-Path $MyInvocation.MyCommand.Definition -Parent
+$exe = ""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  $exe = ".exe"
+}
+& "$basedir/${relativeBinaryPath.replace(/\\/g, '/')}" $args
+exit $LASTEXITCODE
+`;
+    writeFileSync(ps1Shim, ps1Content);
+
+    console.log('✓ Optimized: shims point to native binary (zero overhead)');
+  } catch (err) {
+    // Permission error or other issue - not critical, JS wrapper still works
+    console.log(`⚠ Could not optimize shims: ${err.message}`);
+    console.log('  CLI will work via Node.js wrapper (slightly slower startup)');
+  }
+}
+
+main().catch(console.error);

package/scripts/scroll_and_get_products.js

@@ -0,0 +1,47 @@
+(async () => {
+  window.scrollTo(0, document.body.scrollHeight);
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  
+  const scrollContainers = document.querySelectorAll('._infiniteScroll_center_1twc0_1');
+  const result = {
+    scrollContainersCount: scrollContainers.length,
+    containers: []
+  };
+  
+  scrollContainers.forEach((container, index) => {
+    result.containers.push({
+      index,
+      className: container.className,
+      id: container.id,
+      childrenCount: container.children.length,
+      hasContent: container.children.length > 0
+    });
+    
+    if (container.children.length > 0 && index === 1) {
+      result.products = [];
+      for (let i = 0; i < Math.min(container.children.length, 10); i++) {
+        const product = container.children[i];
+        const productData = {
+          index: i,
+          className: product.className,
+          id: product.id,
+          innerHTML: product.innerHTML.substring(0, 500)
+        };
+        
+        const titleEl = product.querySelector('[class*="title"], [class*="name"]');
+        const priceEl = product.querySelector('[class*="price"]');
+        const shopEl = product.querySelector('[class*="shop"], [class*="store"]');
+        const linkEl = product.querySelector('a[href*="jd"]');
+        
+        if (titleEl) productData.title = titleEl.textContent?.substring(0, 100);
+        if (priceEl) productData.price = priceEl.textContent?.substring(0, 50);
+        if (shopEl) productData.shop = shopEl.textContent?.substring(0, 50);
+        if (linkEl) productData.link = linkEl.href.substring(0, 100);
+        
+        result.products.push(productData);
+      }
+    }
+  });
+  
+  return result;
+})()

package/scripts/scroll_deep_and_find.js

@@ -0,0 +1,45 @@
+(async () => {
+  const result = {
+    scrollPositions: [],
+    products: []
+  };
+  
+  for (let i = 0; i < 10; i++) {
+    const scrollY = window.scrollY;
+    const scrollHeight = document.documentElement.scrollHeight;
+    
+    window.scrollTo(0, scrollY + 500);
+    result.scrollPositions.push({ step: i, scrollY: scrollY + 500 });
+    
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+  
+  await new Promise(resolve => setTimeout(resolve, 3000));
+  
+  const allImages = document.querySelectorAll('img[data-src*="360buy"]');
+  result.imageCount = allImages.length;
+  
+  allImages.forEach((img, index) => {
+    if (index >= 10) return;
+    
+    const parent = img.closest('a') || img.parentElement;
+    if (parent) {
+      const product = {
+        index,
+        imgSrc: img.src || img.getAttribute('data-src')?.substring(0, 100),
+        parentTag: parent.tagName,
+        parentClass: parent.className?.substring(0, 100),
+        link: parent.href || ''
+      };
+      
+      const text = parent.textContent?.trim();
+      if (text) {
+        product.text = text.substring(0, 100);
+      }
+      
+      result.products.push(product);
+    }
+  });
+  
+  return result;
+})()

package/scripts/sync-version.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+/**
+ * Syncs the version from package.json to all other config files.
+ * Run this script before building or releasing.
+ */
+
+import { execSync } from "child_process";
+import { readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, "..");
+const cliDir = join(rootDir, "cli");
+
+// Read version from package.json (single source of truth)
+const packageJson = JSON.parse(
+  readFileSync(join(rootDir, "package.json"), "utf-8")
+);
+const version = packageJson.version;
+
+console.log(`Syncing version ${version} to all config files...`);
+
+// Update Cargo.toml
+const cargoTomlPath = join(cliDir, "Cargo.toml");
+let cargoToml = readFileSync(cargoTomlPath, "utf-8");
+const cargoVersionRegex = /^version\s*=\s*"[^"]*"/m;
+const newCargoVersion = `version = "${version}"`;
+
+let cargoTomlUpdated = false;
+if (cargoVersionRegex.test(cargoToml)) {
+  const oldMatch = cargoToml.match(cargoVersionRegex)?.[0];
+  if (oldMatch !== newCargoVersion) {
+    cargoToml = cargoToml.replace(cargoVersionRegex, newCargoVersion);
+    writeFileSync(cargoTomlPath, cargoToml);
+    console.log(`  Updated cli/Cargo.toml: ${oldMatch} -> ${newCargoVersion}`);
+    cargoTomlUpdated = true;
+  } else {
+    console.log(`  cli/Cargo.toml already up to date`);
+  }
+} else {
+  console.error("  Could not find version field in cli/Cargo.toml");
+  process.exit(1);
+}
+
+// Update Cargo.lock to match Cargo.toml
+if (cargoTomlUpdated) {
+  try {
+    execSync("cargo update -p agent-browser --offline", {
+      cwd: cliDir,
+      stdio: "pipe",
+    });
+    console.log(`  Updated cli/Cargo.lock`);
+  } catch {
+    // --offline may fail if package not in cache, try without it
+    try {
+      execSync("cargo update -p agent-browser", {
+        cwd: cliDir,
+        stdio: "pipe",
+      });
+      console.log(`  Updated cli/Cargo.lock`);
+    } catch (e) {
+      console.error(`  Warning: Could not update Cargo.lock: ${e.message}`);
+    }
+  }
+}
+
+console.log("Version sync complete.");