别再手动写爬虫了！AI驱动的浏览器自动化神器，让你的效率提升10倍

用户自然语言指令
        ↓
Stagehand AI层（意图解析）
        ↓
Playwright执行层（浏览器控制）
        ↓
网页响应反馈
        ↓
AI结果验证

node --version

# 创建项目目录
mkdir my-stagehand-project
cd my-stagehand-project

# 初始化npm项目
npm init -y

# 安装stagehand核心包
npm install stagehand

pip install stagehand-py

# .env文件内容
OPENAI_API_KEY=sk-your-openai-api-key-here
ANTHROPIC_API_KEY=sk-ant-your-anthropic-api-key-here

// stagehand.config.js
const { Stagehand } = require('stagehand');

const stagehand = new Stagehand({
  // 模型配置
  model: 'gpt-4o',  // 使用支持视觉的模型
  provider: 'openai',

  // 浏览器配置
  headless: false,  // 设置为true可在无头模式运行
  browser: 'chromium',  // 可选: chromium, firefox, webkit

  // 调试配置
  verbose: true,  // 输出详细日志
  logger: console.log,

  // 安全与限制
  maxRetries: 3,  // 操作失败重试次数
  timeout: 30000,  // 操作超时时间（毫秒）
});

module.exports = { stagehand };

// first-script.js
const { Stagehand } = require('stagehand');

async function main() {
  // 创建Stagehand实例
  const stagehand = new Stagehand({
    model: 'gpt-4o',
    headless: false,
  });

  try {
    // 初始化
    await stagehand.init();

    // 打开网页
    await stagehand.goto('https://example.com');

    // 使用自然语言操作
    await stagehand.act('获取页面的标题');

    // 提取信息
    const title = await stagehand.extract('页面的主要标题是什么？');
    console.log('提取的标题:', title);

  } catch (error) {
    console.error('执行出错:', error);
  } finally {
    // 清理资源
    await stagehand.close();
  }
}

main();

node first-script.js

// 基础用法
await stagehand.goto('https://www.example.com');

// 带选项的导航
await stagehand.goto('https://www.example.com', {
  timeout: 60000,      // 导航超时时间
  waitUntil: 'networkidle',  // 等待网络空闲
  referer: 'https://google.com',  // 设置引用来源
});

// 等待特定条件
await stagehand.goto('https://www.example.com');
await stagehand.waitForLoadState('domcontentloaded');

// 点击元素
await stagehand.act('点击登录按钮');

// 输入文本
await stagehand.act('在搜索框中输入"人工智能"');

// 悬停和悬停事件
await stagehand.act('鼠标悬停在产品图片上');

// 滚动操作
await stagehand.act('向下滚动页面');

// 组合操作
await stagehand.act('勾选"记住我"复选框');

// 复杂操作
await stagehand.act('点击导航栏中的"关于我们"链接');

// act方法的高级选项
await stagehand.act('填写注册表单', {
  // 操作超时时间
  timeout: 30000,

  // 是否在执行前等待元素可见
  waitForVisible: true,

  // 人类化的延迟（模拟人类操作速度）
  humanlikeDelay: { min: 100, max: 300 },

  // 失败时是否截图
  screenshotOnFailure: true,
});

// 提取单个信息
const title = await stagehand.extract('页面的标题是什么？');
console.log(title);

// 提取多个字段
const productInfo = await stagehand.extract({
  query: '提取所有产品名称和价格',
  // 指定返回格式
  type: 'object',  // 或 'string', 'array', 'json'
});

console.log(productInfo);
// 可能返回: { products: [{ name: '产品A', price: '99元' }, ...] }

// 使用JSON Schema定义期望的返回格式
const structuredData = await stagehand.extract({
  query: '提取文章信息',
  type: 'json',
  schema: {
    title: '文章标题',
    author: '作者姓名',
    publishDate: '发布日期',
    content: '文章摘要（前200字）',
    tags: '所有标签列表',
  },
});

// 批量提取（从列表页面提取多个条目）
const products = await stagehand.extract({
  query: '提取页面上所有商品的信息',
  type: 'array',
  itemSchema: {
    name: '商品名称',
    price: '商品价格',
    rating: '用户评分',
    link: '商品详情页链接',
  },
});

// 等待元素出现
await stagehand.wait('出现了"登录成功"的提示');

// 等待URL匹配
await stagehand.wait('URL变为/dashboard');

// 等待页面状态
await stagehand.wait('页面加载完成');

// 等待特定元素可见
await stagehand.wait('用户头像可见');

// 带超时的等待
await stagehand.wait('弹出了确认对话框', {
  timeout: 10000,
  timeoutMessage: '对话框未在预期时间内出现',
});

const result = await stagehand.do(async (page) => {
  // 第一步：导航到目标页面
  await page.goto('https://www.example.com/login');

  // 第二步：填写表单
  await page.fill('input[name="username"]', 'myuser');
  await page.fill('input[name="password"]', 'mypass');

  // 第三步：点击登录
  await page.click('button[type="submit"]');

  // 第四步：等待跳转
  await page.waitForURL('**/dashboard');

  // 第五步：提取数据
  const welcomeText = await page.textContent('.welcome-message');

  return { success: true, welcomeText };
});

console.log(result);
// { success: true, welcomeText: '欢迎回来，myuser！' }

// login-and-collect.js
const { Stagehand } = require('stagehand');

class DataCollector {
  constructor() {
    this.stagehand = new Stagehand({
      model: 'gpt-4o',
      headless: true,  // 正式运行使用无头模式
      verbose: false,  // 正式运行关闭详细日志
    });
  }

  async initialize() {
    await this.stagehand.init();
    console.log('Stagehand初始化完成');
  }

  async login(username, password) {
    console.log('开始登录流程...');

    // 导航到登录页
    await this.stagehand.goto('https://example-site.com/login');

    // 使用自然语言填写登录表单
    await this.stagehand.act('在用户名输入框中输入' + username);
    await this.stagehand.act('在密码输入框中输入' + password);

    // 点击登录按钮
    await this.stagehand.act('点击登录按钮');

    // 等待登录完成
    await this.stagehand.wait('页面跳转到仪表盘');

    console.log('登录成功！');
  }

  async collectOrderData() {
    console.log('开始采集订单数据...');

    // 导航到订单页面
    await this.stagehand.goto('https://example-site.com/orders');
    await this.stagehand.wait('订单列表加载完成');

    // 提取订单信息
    const orders = await this.stagehand.extract({
      query: '提取所有订单的信息，包括订单号、日期、金额和状态',
      type: 'array',
      itemSchema: {
        orderNumber: '订单号',
        date: '下单日期',
        amount: '订单金额',
        status: '订单状态',
      },
    });

    return orders;
  }

  async close() {
    await this.stagehand.close();
    console.log('资源已清理');
  }
}

// 主函数
async function main() {
  const collector = new DataCollector();

  try {
    await collector.initialize();
    await collector.login('your_username', 'your_password');

    // 采集数据
    const orderData = await collector.collectOrderData();

    console.log('\n===== 采集到的订单数据 =====');
    console.log(JSON.stringify(orderData, null, 2));

    // 这里可以添加数据存储逻辑
    // await saveToDatabase(orderData);

  } catch (error) {
    console.error('执行过程中发生错误:', error.message);
    // 发生错误时截图保存
    await collector.stagehand.takeScreenshot('error-screenshot.png');
  } finally {
    await collector.close();
  }
}

main();

// batch-form-submission.js
const { Stagehand } = require('stagehand');

async function fillRegistrationForm(userData) {
  const stagehand = new Stagehand({ model: 'gpt-4o' });

  try {
    await stagehand.init();
    await stagehand.goto('https://example-site.com/register');

    // 基本信息填写
    await stagehand.act(`在"姓名"字段输入: ${userData.name}`);
    await stagehand.act(`在"邮箱"字段输入: ${userData.email}`);
    await stagehand.act(`在"手机号"字段输入: ${userData.phone}`);
    await stagehand.act(`在"密码"字段输入: ${userData.password}`);
    await stagehand.act(`在"确认密码"字段输入: ${userData.password}`);

    // 处理单选按钮（性别选择）
    await stagehand.act(`选择性别: ${userData.gender}`);

    // 处理复选框（兴趣标签）
    for (const interest of userData.interests) {
      await stagehand.act(`勾选"${interest}"选项`);
    }

    // 处理下拉选择
    await stagehand.act(`在国家下拉框中选择: ${userData.country}`);
    await stagehand.act(`在城市下拉框中选择: ${userData.city}`);

    // 处理日期选择
    await stagehand.act(`选择出生日期: ${userData.birthday}`);

    // 处理文件上传
    await stagehand.act(`上传头像图片`, {
      // 可以传递文件路径
      // files: ['./avatar.jpg']
    });

    // 滚动到页面底部（如果有协议同意框）
    await stagehand.act('向下滚动到页面底部');

    // 处理协议同意
    await stagehand.act('勾选"我已阅读并同意用户协议"');

    // 提交表单
    await stagehand.act('点击"注册"按钮');

    // 等待并处理可能的验证
    await stagehand.wait('注册成功提示或错误提示');

    // 检查注册结果
    const result = await stagehand.extract('页面上显示的注册结果是什么？');

    console.log('注册结果:', result);

  } finally {
    await stagehand.close();
  }
}

// 使用示例
const userData = {
  name: '张三',
  email: 'zhangsan@example.com',
  phone: '13800138000',
  password: 'SecurePass123!',
  gender: '男',
  interests: ['阅读', '编程', '旅游'],
  country: '中国',
  city: '北京',
  birthday: '1995-06-15',
};

fillRegistrationForm(userData);

// pagination-scraper.js
const { Stagehand } = require('stagehand');

class PaginatedScraper {
  constructor() {
    this.stagehand = new Stagehand({
      model: 'gpt-4o',
      headless: true,
    });
    this.maxPages = 10;  // 最大采集页数限制
    this.allData = [];
  }

  async scrapeListPage(url, itemSelector) {
    await this.stagehand.goto(url);
    await this.stagehand.wait('列表内容加载完成');

    let pageCount = 0;

    while (pageCount < this.maxPages) {
      console.log(`正在采集第 ${pageCount + 1} 页...`);

      // 提取当前页的所有项目
      const items = await this.stagehand.extract({
        query: '提取当前页面所有文章的信息',
        type: 'array',
        itemSchema: {
          title: '文章标题',
          author: '作者',
          publishDate: '发布日期',
          summary: '文章摘要',
          url: '文章链接',
        },
      });

      this.allData.push(...items);
      console.log(`第 ${pageCount + 1} 页: 获取 ${items.length} 条数据`);

      // 检查是否有下一页
      const hasNextPage = await this.checkNextPage();

      if (!hasNextPage) {
        console.log('已到达最后一页');
        break;
      }

      // 点击下一页
      await this.stagehand.act('点击"下一页"按钮');
      await this.stagehand.wait('新内容加载完成');

      pageCount++;

      // 添加礼貌性延迟，避免对服务器造成压力
      await this.delay(1000 + Math.random() * 1000);
    }

    return this.allData;
  }

  async checkNextPage() {
    // 尝试提取判断是否还有下一页
    const pagination = await this.stagehand.extract({
      query: '当前页码和总页码分别是多少？',
      type: 'object',
    });

    // 如果当前页码小于总页码，说明还有下一页
    if (pagination.current && pagination.total) {
      return pagination.current < pagination.total;
    }

    // 备选方案：检查"下一页"按钮是否可点击
    try {
      const buttonDisabled = await this.stagehand.evaluate(() => {
        const nextBtn = document.querySelector('.pagination .next');
        return nextBtn ? nextBtn.disabled : true;
      });
      return !buttonDisabled;
    } catch {
      return false;
    }
  }

  async scrapeInfiniteScroll(url) {
    console.log(`开始采集无限滚动页面: ${url}`);
    await this.stagehand.goto(url);

    let previousHeight = 0;
    let scrollCount = 0;
    const maxScrolls = 50;  // 最大滚动次数

    while (scrollCount < maxScrolls) {
      // 提取当前可见区域的内容
      const visibleItems = await this.stagehand.extract({
        query: '提取当前可见的所有产品信息',
        type: 'array',
        itemSchema: {
          name: '产品名称',
          price: '产品价格',
          rating: '产品评分',
        },
      });

      // 添加到总数据（去重处理）
      for (const item of visibleItems) {
        if (!this.isDuplicate(item)) {
          this.allData.push(item);
        }
      }

      console.log(`滚动 ${scrollCount + 1}: 当前累计 ${this.allData.length} 条数据`);

      // 获取当前页面高度
      const currentHeight = await this.stagehand.evaluate(() => {
        return document.documentElement.scrollHeight;
      });

      // 如果高度没有变化，说明已经加载完毕
      if (currentHeight === previousHeight) {
        console.log('页面已滚动到底部');
        break;
      }

      // 向下滚动
      await this.stagehand.act('向下滚动到底部');
      scrollCount++;

      // 等待新内容加载
      await this.delay(1500 + Math.random() * 500);

      previousHeight = currentHeight;
    }

    return this.allData;
  }

  isDuplicate(newItem) {
    return this.allData.some(
      existing => existing.name === newItem.name
    );
  }

  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  async close() {
    await this.stagehand.close();
  }
}

// 使用示例 - 采集分页列表
async function main() {
  const scraper = new PaginatedScraper();

  try {
    await scraper.stagehand.init();

    // 采集分页列表
    const articles = await scraper.scrapeListPage(
      'https://example-blog.com/articles',
      '.article-card'
    );

    console.log(`\n总共采集到 ${articles.length} 篇文章`);
    console.log(JSON.stringify(articles.slice(0, 5), null, 2));

  } finally {
    await scraper.close();
  }
}

main();

// handle-modals.js
const { Stagehand } = require('stagehand');

async function handleVariousPopups() {
  const stagehand = new Stagehand({
    model: 'gpt-4o',
    headless: true,
  });

  try {
    await stagehand.init();
    await stagehand.goto('https://example-site.com');

    // ============================================
    // 场景1：处理Cookie同意弹窗
    // ============================================
    try {
      // 尝试多种可能的关闭方式
      await stagehand.act('点击"接受所有Cookie"按钮', { timeout: 3000 });
      console.log('Cookie弹窗已处理');
    } catch {
      try {
        await stagehand.act('点击"好的，我知道了"按钮', { timeout: 2000 });
      } catch {
        try {
          await stagehand.act('关闭Cookie提示', { timeout: 2000 });
        } catch {
          console.log('未检测到Cookie弹窗，继续执行');
        }
      }
    }

    // ============================================
    // 场景2：处理公告/通知弹窗
    // ============================================
    await stagehand.wait('页面完全加载');

    // 检查并关闭可能出现的公告弹窗
    const hasAnnouncement = await stagehand.check('是否有弹窗出现？');

    if (hasAnnouncement) {
      await stagehand.act('关闭弹窗或点击"不再显示"复选框后关闭');
      console.log('公告弹窗已处理');
    }

    // ============================================
    // 场景3：处理确认对话框
    // ============================================
    // 例如：删除操作前的确认
    await stagehand.act('点击删除按钮');

    const dialogVisible = await stagehand.wait('确认对话框出现', { timeout: 5000 });

    if (dialogVisible) {
      // 根据业务逻辑决定是确认还是取消
      const confirmDelete = true;  // 或根据其他条件判断

      if (confirmDelete) {
        await stagehand.act('在确认对话框中点击"确定"');
      } else {
        await stagehand.act('在确认对话框中点击"取消"');
      }
    }

    // ============================================
    // 场景4：处理登录/注册弹窗
    // ============================================
    await stagehand.act('点击"登录"按钮');
    await stagehand.wait('登录弹窗打开');

    // 在弹窗中填写登录信息
    await stagehand.act('在弹窗中的用户名输入框输入"testuser"');
    await stagehand.act('在弹窗中的密码输入框输入"testpass"');
    await stagehand.act('点击弹窗中的登录按钮');

    // ============================================
    // 场景5：处理iframe内的内容
    // ============================================
    // 有些弹窗内容在iframe中
    try {
      await stagehand.act('切换到弹窗的iframe中');

      // 在iframe内操作
      await stagehand.act('填写iframe内的表单');

      // 操作完成后切回主文档
      await stagehand.act('切换回主文档');
    } catch {
      console.log('弹窗不在iframe中或iframe切换失败');
    }

    // ============================================
    // 场景6：处理嵌套弹窗
    // ============================================
    // 先处理内层弹窗
    await stagehand.act('关闭内层弹窗');
    await this.delay(300);

    // 再处理外层弹窗
    await stagehand.act('在外层弹窗中点击确定');

  } finally {
    await stagehand.close();
  }
}

// 通用弹窗处理策略
async function smartPopupHandler(stagehand) {
  const popupStrategies = [
    // 策略1：查找并点击关闭按钮
    async () => {
      const closeSelectors = [
        '[aria-label="Close"]',
        '.modal-close',
        '.popup-close',
        '.close-btn',
        '[class*="close"]',
        'button:has-text("关闭")',
        'button:has-text("×")',
      ];

      for (const selector of closeSelectors) {
        try {
          await stagehand.click(selector);
          return true;
        } catch {
          continue;
        }
      }
      return false;
    },

    // 策略2：点击遮罩层关闭
    async () => {
      try {
        await stagehand.click('.modal-overlay', { position: { x: 10, y: 10 } });
        return true;
      } catch {
        return false;
      }
    },

    // 策略3：按ESC键关闭
    async () => {
      try {
        await stagehand.keyboard.press('Escape');
        return true;
      } catch {
        return false;
      }
    },
  ];

  for (const strategy of popupStrategies) {
    try {
      const handled = await strategy();
      if (handled) {
        await stagehand.wait('弹窗消失');
        return true;
      }
    } catch {
      continue;
    }
  }

  return false;
}

module.exports = { handleVariousPopups, smartPopupHandler };

// ecommerce-scraper.js
const { Stagehand } = require('stagehand');

class EcommerceScraper {
  constructor(config) {
    this.config = {
      headless: true,
      ...config,
    };
    this.stagehand = new Stagehand({
      model: 'gpt-4o',
      ...this.config,
    });
    this.products = [];
  }

  async initialize() {
    await this.stagehand.init();
    console.log('电商数据采集器已就绪');
  }

  async searchProducts(keyword) {
    console.log(`开始搜索: ${keyword}`);

    // 导航到搜索页面
    await this.stagehand.goto('https://ecommerce-example.com/search');

    // 输入搜索关键词
    await this.stagehand.act(`在搜索框中输入"${keyword}"并按回车`);

    // 等待搜索结果加载
    await this.stagehand.wait('搜索结果列表出现');

    console.log('搜索完成，开始采集...');
  }

  async filterResults(filters) {
    // 应用价格筛选
    if (filters.minPrice || filters.maxPrice) {
      const priceText = filters.minPrice && filters.maxPrice
        ? `${filters.minPrice}到${filters.maxPrice}`
        : filters.minPrice
          ? `${filters.minPrice}以上`
          : `${filters.maxPrice}以下`;

      await this.stagehand.act(`设置价格筛选为${priceText}`);
      await this.stagehand.wait('筛选结果更新');
    }

    // 应用评分筛选
    if (filters.minRating) {
      await this.stagehand.act(`筛选${filters.minRating}星及以上商品`);
      await this.stagehand.wait('筛选结果更新');
    }

    // 选择排序方式
    if (filters.sortBy) {
      const sortMap = {
        'price-low': '价格从低到高',
        'price-high': '价格从高到低',
        'sales': '销量优先',
        'rating': '评分优先',
        'newest': '新品优先',
      };

      await this.stagehand.act(`按"${sortMap[filters.sortBy] || filters.sortBy}"排序`);
      await this.stagehand.wait('排序结果更新');
    }
  }

  async collectProductList(maxPages = 5) {
    let pageNum = 0;

    while (pageNum < maxPages) {
      console.log(`\n正在采集第 ${pageNum + 1} 页...`);

      // 采集当前页商品列表
      const pageProducts = await this.collectCurrentPageProducts();
      this.products.push(...pageProducts);

      console.log(`第 ${pageNum + 1} 页: 新增 ${pageProducts.length} 个商品`);
      console.log(`累计已采集: ${this.products.length} 个商品`);

      // 检查是否还有下一页
      const hasNextPage = await this.checkPagination(pageNum);

      if (!hasNextPage) {
        console.log('已到达最后一页');
        break;
      }

      // 点击下一页
      await this.stagehand.act('点击下一页按钮');
      await this.stagehand.wait('新页商品加载完成');

      pageNum++;

      // 礼貌性延迟
      await this.delay(1500 + Math.random() * 1000);
    }

    return this.products;
  }

  async collectCurrentPageProducts() {
    // 提取当前页所有商品的简要信息
    const productSummaries = await this.stagehand.extract({
      query: '提取当前页面所有商品的简要信息',
      type: 'array',
      itemSchema: {
        id: '商品ID或编号',
        title: '商品标题/名称',
        price: '商品价格',
        originalPrice: '原价（如有折扣）',
        rating: '商品评分',
        sales: '销量',
        shop: '店铺名称',
        link: '商品详情页链接',
      },
    });

    return productSummaries;
  }

  async collectProductDetails(productLink) {
    console.log(`正在采集商品详情: ${productLink}`);

    // 在新标签页打开商品详情
    await this.stagehand.goto(productLink, { waitUntil: 'networkidle' });

    // 提取详细信息
    const details = await this.stagehand.extract({
      query: '提取商品的详细信息',
      type: 'object',
      schema: {
        title: '商品标题',
        price: '商品价格',
        description: '商品详细描述',
        images: '商品图片URL列表',
        specifications: '商品规格参数',
        shop: {
          name: '店铺名称',
          rating: '店铺评分',
          location: '店铺所在地',
        },
        shipping: '发货信息',
        stock: '库存状态',
        reviews: '用户评价概要',
      },
    });

    // 返回主列表页
    await this.stagehand.goBack();
    await this.stagehand.wait('商品列表恢复');

    return details;
  }

  async checkPagination(currentPage) {
    // 检查分页信息
    try {
      const pageInfo = await this.stagehand.extract({
        query: '当前在第几页？是否有下一页？',
        type: 'object',
      });

      return pageInfo.hasNextPage;
    } catch {
      // 尝试直接检查下一页按钮
      try {
        const nextBtn = await this.stagehand.$('.pagination .next:not([disabled])');
        return nextBtn !== null;
      } catch {
        return false;
      }
    }
  }

  async collectReviews(maxReviews = 50) {
    console.log('开始采集商品评论...');

    // 提取评论列表
    const reviews = [];
    let collected = 0;

    while (collected < maxReviews) {
      const pageReviews = await this.stagehand.extract({
        query: '提取当前页所有评论内容',
        type: 'array',
        itemSchema: {
          author: '评论者名称',
          date: '评论日期',
          rating: '评分',
          content: '评论正文',
          likes: '点赞数',
          images: '评论晒图',
        },
      });

      reviews.push(...pageReviews);
      collected += pageReviews.length;

      console.log(`已采集 ${reviews.length} 条评论`);

      // 检查是否有下一页评论
      const hasMoreReviews = await this.stagehand.check('是否有更多评论可加载？');

      if (!hasMoreReviews || reviews.length >= maxReviews) {
        break;
      }

      await this.stagehand.act('加载更多评论');
      await this.stagehand.wait('新评论加载完成');

      await this.delay(1000);
    }

    return reviews;
  }

  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  async generateReport() {
    // 生成数据报告
    const report = {
      totalProducts: this.products.length,
      collectedAt: new Date().toISOString(),
      summary: {
        priceRange: this.getPriceRange(),
        avgRating: this.getAverageRating(),
        topShops: this.getTopShops(),
      },
      products: this.products,
    };

    console.log('\n===== 数据采集报告 =====');
    console.log(`总计采集商品: ${report.totalProducts}`);
    console.log(`价格区间: ${report.summary.priceRange}`);
    console.log(`平均评分: ${report.summary.avgRating.toFixed(2)}`);
    console.log(`热卖店铺: ${report.summary.topShops.join(', ')}`);

    return report;
  }

  getPriceRange() {
    const prices = this.products.map(p => parseFloat(p.price));
    const min = Math.min(...prices);
    const max = Math.max(...prices);
    return `${min} - ${max}`;
  }

  getAverageRating() {
    const ratings = this.products
      .map(p => parseFloat(p.rating))
      .filter(r => !isNaN(r));

    return ratings.reduce((sum, r) => sum + r, 0) / ratings.length;
  }

  getTopShops() {
    const shopCount = {};

    this.products.forEach(p => {
      shopCount[p.shop] = (shopCount[p.shop] || 0) + 1;
    });

    return Object.entries(shopCount)
      .sort((a, b) => b[1] - a[1])
      .slice(0, 5)
      .map(([shop]) => shop);
  }

  async saveToFile(filename = 'products.json') {
    const fs = require('fs').promises;
    await fs.writeFile(
      filename,
      JSON.stringify(this.products, null, 2),
      'utf-8'
    );
    console.log(`数据已保存到 ${filename}`);
  }

  async close() {
    await this.stagehand.close();
    console.log('采集器已关闭');
  }
}

// 主函数
async function main() {
  const scraper = new EcommerceScraper();

  try {
    await scraper.initialize();

    // 搜索商品
    await scraper.searchProducts('无线蓝牙耳机');

    // 应用筛选
    await scraper.filterResults({
      minPrice: 100,
      maxPrice: 500,
      minRating: 4.0,
      sortBy: 'sales',
    });

    // 采集商品列表（3页）
    await scraper.collectProductList(3);

    // 采集第一个商品的详情
    if (scraper.products.length > 0) {
      const firstProduct = scraper.products[0];
      const details = await scraper.collectProductDetails(firstProduct.link);
      console.log('商品详情:', details);
    }

    // 生成报告并保存
    await scraper.generateReport();
    await scraper.saveToFile('ecommerce-products.json');

  } catch (error) {
    console.error('采集过程中出错:', error);
  } finally {
    await scraper.close();
  }
}

main();

// robust-error-handling.js
const { Stagehand } = require('stagehand');

class RobustAutomation {
  constructor() {
    this.stagehand = new Stagehand({
      model: 'gpt-4o',
      headless: true,
    });

    // 配置重试策略
    this.retryConfig = {
      maxRetries: 3,
      baseDelay: 1000,
      maxDelay: 10000,
      exponentialBackoff: true,
    };
  }

  // 带重试的包装函数
  async withRetry(operation, context = '操作') {
    let lastError;

    for (let attempt = 1; attempt <= this.retryConfig.maxRetries; attempt++) {
      try {
        console.log(`${context}: 第 ${attempt} 次尝试...`);
        return await operation();

      } catch (error) {
        lastError = error;
        console.error(`${context} 失败 (尝试 ${attempt}/${this.retryConfig.maxRetries}):`, error.message);

        if (attempt < this.retryConfig.maxRetries) {
          // 计算延迟时间（指数退避）
          const delay = this.calculateDelay(attempt);
          console.log(`等待 ${delay}ms 后重试...`);
          await this.delay(delay);
        }
      }
    }

    // 所有重试都失败后
    console.error(`${context} 在 ${this.retryConfig.maxRetries} 次尝试后仍然失败`);
    throw lastError;
  }

  calculateDelay(attempt) {
    if (this.retryConfig.exponentialBackoff) {
      const delay = this.retryConfig.baseDelay * Math.pow(2, attempt - 1);
      return Math.min(delay, this.retryConfig.maxDelay);
    }
    return this.retryConfig.baseDelay;
  }

  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  // 安全的页面操作
  async safeAct(instruction, options = {}) {
    return this.withRetry(async () => {
      // 操作前截图（用于调试）
      if (options.screenshotBefore) {
        await this.stagehand.takeScreenshot('before-action.png');
      }

      const result = await this.stagehand.act(instruction, {
        timeout: options.timeout || 30000,
      });

      // 操作后截图
      if (options.screenshotAfter) {
        await this.stagehand.takeScreenshot('after-action.png');
      }

      return result;
    }, `执行操作: ${instruction}`);
  }

  // 安全的导航
  async safeGoto(url, options = {}) {
    return this.withRetry(async () => {
      console.log(`正在导航到: ${url}`);

      await this.stagehand.goto(url, {
        timeout: options.timeout || 60000,
        waitUntil: options.waitUntil || 'networkidle',
      });

      // 验证页面加载成功
      await this.validatePageLoaded();

      return true;
    }, `导航到 ${url}`);
  }

  async validatePageLoaded() {
    // 检查页面是否正常加载
    const title = await this.stagehand.title();

    if (!title || title.includes('error') || title.includes('404')) {
      throw new Error(`页面加载异常: ${title}`);
    }

    // 检查是否有明显的错误提示
    const hasError = await this.stagehand.evaluate(() => {
      const errorElements = document.querySelectorAll(
        '.error, .error-page, [class*="error"]'
      );
      return errorElements.length > 0;
    });

    if (hasError) {
      throw new Error('页面包含错误元素');
    }
  }

  // 全局错误处理器
  setupGlobalErrorHandlers() {
    process.on('unhandledRejection', async (reason, promise) => {
      console.error('未处理的Promise拒绝:', reason);
      await this.takeErrorSnapshot('unhandled-rejection');
    });

    process.on('uncaughtException', async (error) => {
      console.error('未捕获的异常:', error);
      await this.takeErrorSnapshot('uncaught-exception');
    });
  }

  async takeErrorSnapshot(label) {
    try {
      const filename = `error-${label}-${Date.now()}.png`;
      await this.stagehand.takeScreenshot(filename);
      console.log(`错误快照已保存: ${filename}`);
    } catch {
      console.error('无法保存错误快照');
    }
  }
}

// 使用示例
async function main() {
  const automation = new RobustAutomation();

  // 设置全局错误处理
  automation.setupGlobalErrorHandlers();

  try {
    await automation.stagehand.init();

    // 安全导航
    await automation.safeGoto('https://example-site.com', {
      timeout: 30000,
    });

    // 安全操作
    await automation.safeAct('点击登录按钮', {
      screenshotBefore: true,
      screenshotAfter: true,
      timeout: 15000,
    });

  } catch (error) {
    console.error('执行失败:', error);
    await automation.takeErrorSnapshot('final-error');
  } finally {
    await automation.stagehand.close();
  }
}

main();

// parallel-execution.js
const { Stagehand } = require('stagehand');
const pLimit = require('p-limit');  // 并发限制库

class ParallelScraper {
  constructor(maxConcurrent = 3) {
    this.maxConcurrent = maxConcurrent;
    this.limit = pLimit(maxConcurrent);
  }

  // 创建独立的Stagehand实例
  createInstance(instanceId) {
    return new Stagehand({
      model: 'gpt-4o',
      headless: true,
      verbose: false,
    });
  }

  // 并行采集多个页面
  async scrapeMultiple(urls) {
    console.log(`开始并行采集 ${urls.length} 个页面 (最大并发: ${this.maxConcurrent})`);

    // 使用Promise.all并行执行所有任务
    const tasks = urls.map((url, index) =>
      this.limit(async () => {
        console.log(`[${index + 1}/${urls.length}] 开始采集: ${url}`);

        const instance = this.createInstance(index);

        try {
          await instance.init();
          await instance.goto(url);

          const data = await instance.extract({
            query: '提取页面标题和主要内容',
            type: 'object',
          });

          console.log(`[${index + 1}/${urls.length}] 完成: ${url}`);

          return {
            url,
            success: true,
            data,
          };

        } catch (error) {
          console.error(`[${index + 1}/${urls.length}] 失败: ${url}`, error.message);

          return {
            url,
            success: false,
            error: error.message,
          };

        } finally {
          await instance.close();
        }
      })
    );

    const results = await Promise.all(tasks);

    console.log('\n===== 采集完成 =====');
    console.log(`成功: ${results.filter(r => r.success).length}`);
    console.log(`失败: ${results.filter(r => !r.success).length}`);

    return results;
  }

  // 分批处理（适合大量URL）
  async scrapeInBatches(urls, batchSize = 10) {
    const allResults = [];

    for (let i = 0; i < urls.length; i += batchSize) {
      const batch = urls.slice(i, i + batchSize);
      console.log(`\n处理批次 ${Math.floor(i / batchSize) + 1}: 包含 ${batch.length} 个URL`);

      const batchResults = await this.scrapeMultiple(batch);
      allResults.push(...batchResults);

      // 批次间延迟
      if (i + batchSize < urls.length) {
        console.log('批次间等待...');
        await new Promise(resolve => setTimeout(resolve, 3000));
      }
    }

    return allResults;
  }

  // 使用工作池模式
  async scrapeWithWorkerPool(urls, workerCount = 5) {
    console.log(`启动工作池 (${workerCount} 个worker)`);

    // 创建worker队列
    const workers = Array.from({ length: workerCount }, (_, i) => i);
    const urlQueue = [...urls];
    const results = [];

    // 每个worker的处理函数
    const workerTask = async (workerId) => {
      const workerResults = [];

      while (urlQueue.length > 0) {
        // 从队列取出一个URL
        const url = urlQueue.shift();

        if (!url) break;

        console.log(`[Worker ${workerId}] 处理: ${url}`);

        const instance = this.createInstance(workerId);

        try {
          await instance.init();
          await instance.goto(url);

          const data = await instance.extract({
            query: '提取页面数据',
            type: 'object',
          });

          workerResults.push({ url, success: true, data });

        } catch (error) {
          workerResults.push({ url, success: false, error: error.message });

        } finally {
          await instance.close();
        }

        // 任务间延迟（避免过快）
        await new Promise(resolve => setTimeout(resolve, 500 + Math.random() * 500));
      }

      return workerResults;
    };

    // 并行运行所有worker
    const workerResults = await Promise.all(
      workers.map(id => workerTask(id))
    );

    // 合并结果
    for (const workerResult of workerResults) {
      results.push(...workerResult);
    }

    return results;
  }
}

// 使用示例
async function main() {
  const scraper = new ParallelScraper(maxConcurrent = 3);

  // 准备URL列表
  const urls = [
    'https://example-site.com/page/1',
    'https://example-site.com/page/2',
    'https://example-site.com/page/3',
    'https://example-site.com/page/4',
    'https://example-site.com/page/5',
  ];

  // 选择一种执行方式
  // 1. 直接并行（URL数量较少时）
  const results = await scraper.scrapeMultiple(urls);

  // 2. 分批处理（URL数量较多时）
  // const results = await scraper.scrapeInBatches(urls, batchSize = 5);

  // 3. 工作池模式（自定义并发数）
  // const results = await scraper.scrapeWithWorkerPool(urls, workerCount = 5);

  console.log('\n所有任务完成');
  console.log(JSON.stringify(results, null, 2));
}

main();

// context-management.js
const { Stagehand } = require('stagehand');
const fs = require('fs');

class StatefulScraper {
  constructor() {
    this.stagehand = new Stagehand({
      model: 'gpt-4o',
      headless: true,
    });
    this.stateFile = './session-state.json';
    this.sessionState = {};
  }

  async initialize() {
    // 尝试恢复之前的会话状态
    await this.loadState();

    await this.stagehand.init();

    // 如果有保存的cookies，恢复登录状态
    if (this.sessionState.cookies) {
      console.log('恢复会话状态...');
      await this.restoreSession();
    }
  }

  async loadState() {
    try {
      if (fs.existsSync(this.stateFile)) {
        const data = fs.readFileSync(this.stateFile, 'utf-8');
        this.sessionState = JSON.parse(data);
        console.log('已加载保存的状态');
      }
    } catch (error) {
      console.log('无法加载状态文件，将创建新会话');
      this.sessionState = {};
    }
  }

  async saveState() {
    try {
      // 保存cookies
      this.sessionState.cookies = await this.stagehand.context.cookies();

      // 保存localStorage
      this.sessionState.localStorage = await this.stagehand.evaluate(() => {
        const data = {};
        for (let i = 0; i < localStorage.length; i++) {
          const key = localStorage.key(i);
          data[key] = localStorage.getItem(key);
        }
        return data;
      });

      // 保存sessionStorage
      this.sessionState.sessionStorage = await this.stagehand.evaluate(() => {
        const data = {};
        for (let i = 0; i < sessionStorage.length; i++) {
          const key = sessionStorage.key(i);
          data[key] = sessionStorage.getItem(key);
        }
        return data;
      });

      // 保存当前URL
      this.sessionState.lastUrl = this.stagehand.url();

      // 保存时间戳
      this.sessionState.savedAt = new Date().toISOString();

      fs.writeFileSync(
        this.stateFile,
        JSON.stringify(this.sessionState, null, 2)
      );

      console.log('状态已保存');
    } catch (error) {
      console.error('保存状态失败:', error);
    }
  }

  async restoreSession() {
    try {
      // 恢复cookies
      if (this.sessionState.cookies) {
        await this.stagehand.context.addCookies(this.sessionState.cookies);
      }

      // 打开任意页面以设置storage
      await this.stagehand.goto(this.sessionState.lastUrl || 'https://example.com');

      // 恢复localStorage
      if (this.sessionState.localStorage) {
        await this.stagehand.evaluate((data) => {
          for (const [key, value] of Object.entries(data)) {
            localStorage.setItem(key, value);
          }
        }, this.sessionState.localStorage);
      }

      // 恢复sessionStorage
      if (this.sessionState.sessionStorage) {
        await this.stagehand.evaluate((data) => {
          for (const [key, value] of Object.entries(data)) {
            sessionStorage.setItem(key, value);
          }
        }, this.sessionState.sessionStorage);
      }

      console.log('会话状态已恢复');

    } catch (error) {
      console.error('恢复会话失败:', error);
      this.sessionState = {};
    }
  }

  // 渐进式保存
  async checkpoint(name) {
    this.sessionState.checkpoints = this.sessionState.checkpoints || {};
    this.sessionState.checkpoints[name] = {
      url: await this.stagehand.url(),
      timestamp: new Date().toISOString(),
    };

    // 每10个checkpoint保存一次
    const checkpointCount = Object.keys(this.sessionState.checkpoints).length;
    if (checkpointCount % 10 === 0) {
      await this.saveState();
    }
  }

  // 从checkpoint恢复
  async restoreCheckpoint(name) {
    const checkpoint = this.sessionState.checkpoints?.[name];

    if (checkpoint) {
      await this.stagehand.goto(checkpoint.url);
      console.log(`已恢复到checkpoint: ${name}`);
    } else {
      console.log(`未找到checkpoint: ${name}`);
    }
  }

  async close() {
    await this.saveState();
    await this.stagehand.close();
  }
}

// 使用示例
async function main() {
  const scraper = new StatefulScraper();

  try {
    await scraper.initialize();

    // 登录流程
    await scraper.stagehand.goto('https://example-site.com/login');
    await scraper.stagehand.act('填写登录表单');
    await scraper.stagehand.act('点击登录');

    // 保存登录状态
    await scraper.saveState();
    await scraper.checkpoint('after-login');

    // 继续其他操作...
    await scraper.stagehand.goto('https://example-site.com/dashboard');
    await scraper.checkpoint('dashboard');

    // 后续运行时会自动恢复登录状态
    await scraper.close();

  } catch (error) {
    console.error('执行出错:', error);
  }
}

main();