OpenClaw 与 Node.js 集成有多种方式，具体取决于您的使用场景。以下是几种常见的集成方法

作为独立服务集成（推荐）

通过 REST API 调用

const axios = require('axios');
class OpenClawClient {
  constructor(baseURL = 'http://localhost:8080') {
    this.client = axios.create({ baseURL });
  }
  async createClawTask(config) {
    const response = await this.client.post('/api/tasks', config);
    return response.data;
  }
  async getTaskStatus(taskId) {
    const response = await this.client.get(`/api/tasks/${taskId}`);
    return response.data;
  }
  async stopTask(taskId) {
    const response = await this.client.delete(`/api/tasks/${taskId}`);
    return response.data;
  }
}

通过 CLI 集成

const { exec, spawn } = require('child_process');
const { promisify } = require('util');
const execAsync = promisify(exec);
class OpenClawCLI {
  async runCommand(config) {
    const command = `openclaw --config ${JSON.stringify(config)}`;
    try {
      const { stdout, stderr } = await execAsync(command);
      return { success: true, output: stdout };
    } catch (error) {
      return { success: false, error: error.message };
    }
  }
  async streamOutput(config) {
    return new Promise((resolve, reject) => {
      const process = spawn('openclaw', ['--config', JSON.stringify(config)]);
      let output = '';
      process.stdout.on('data', (data) => {
        output += data.toString();
        // 实时处理输出
        console.log('OpenClaw:', data.toString());
      });
      process.stderr.on('data', (data) => {
        console.error('OpenClaw Error:', data.toString());
      });
      process.on('close', (code) => {
        resolve({ code, output });
      });
    });
  }
}

通过 SDK/NPM 包集成

OpenClaw 提供 Node.js SDK：

const OpenClaw = require('openclaw-sdk');
// 初始化客户端
const client = new OpenClaw({
  apiKey: process.env.OPENCLAW_API_KEY,
  endpoint: 'https://api.openclaw.com'
});
// 使用示例
async function processDataWithOpenClaw() {
  try {
    // 创建任务
    const task = await client.tasks.create({
      source: 'https://example.com',
      selectors: ['h1', 'p.content'],
      format: 'json'
    });
    // 轮询状态
    let result;
    while (true) {
      const status = await client.tasks.getStatus(task.id);
      if (status.completed) {
        result = status.result;
        break;
      }
      await sleep(2000); // 等待2秒
    }
    return result;
  } catch (error) {
    console.error('OpenClaw processing failed:', error);
  }
}

事件驱动集成

const EventEmitter = require('events');
const WebSocket = require('ws');
class OpenClawWebSocketClient extends EventEmitter {
  constructor(url) {
    super();
    this.url = url;
    this.ws = null;
  }
  connect() {
    this.ws = new WebSocket(this.url);
    this.ws.on('open', () => {
      console.log('Connected to OpenClaw WebSocket');
      this.emit('connected');
    });
    this.ws.on('message', (data) => {
      const message = JSON.parse(data);
      this.emit(message.type, message.data);
    });
    this.ws.on('error', (error) => {
      this.emit('error', error);
    });
  }
  sendTask(config) {
    this.ws.send(JSON.stringify({
      type: 'create_task',
      data: config
    }));
  }
}

Express.js 中间件集成

const express = require('express');
const app = express();
// OpenClaw 中间件
function openClawMiddleware(req, res, next) {
  // 从请求中提取配置
  const config = {
    url: req.body.url,
    selectors: req.body.selectors || ['*']
  };
  // 异步处理
  processWithOpenClaw(config)
    .then(result => {
      req.openClawResult = result;
      next();
    })
    .catch(next);
}
// 使用中间件的路由
app.post('/scrape', openClawMiddleware, (req, res) => {
  res.json({
    success: true,
    data: req.openClawResult
  });
});
// 批量处理路由
app.post('/batch-scrape', async (req, res) => {
  const urls = req.body.urls;
  const promises = urls.map(url => 
    processWithOpenClaw({ url, selectors: req.body.selectors })
  );
  try {
    const results = await Promise.all(promises);
    res.json({ results });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

Queue Worker 集成

const Bull = require('bull');
const Redis = require('ioredis');
// 创建队列
const openClawQueue = new Bull('openclaw-tasks', {
  redis: process.env.REDIS_URL
});
// 处理器
openClawQueue.process(async (job) => {
  const { config } = job.data;
  // 调用 OpenClaw
  const result = await callOpenClawAPI(config);
  // 处理结果
  await storeResult(result);
  return result;
});
// 添加任务
async function addOpenClawTask(config, options = {}) {
  return await openClawQueue.add({
    config,
    timestamp: Date.now()
  }, {
    attempts: 3,
    backoff: {
      type: 'exponential',
      delay: 1000
    },
    ...options
  });
}

环境配置示例

// config/openclaw.js
module.exports = {
  development: {
    endpoint: 'http://localhost:8080',
    timeout: 30000,
    retries: 3
  },
  production: {
    endpoint: process.env.OPENCLAW_ENDPOINT,
    apiKey: process.env.OPENCLAW_API_KEY,
    timeout: 60000,
    retries: 5
  }
};
// utils/openclaw-helper.js
const config = require('../config/openclaw')[process.env.NODE_ENV];
class OpenClawHelper {
  static async withRetry(operation, maxRetries = config.retries) {
    let lastError;
    for (let i = 0; i < maxRetries; i++) {
      try {
        return await operation();
      } catch (error) {
        lastError = error;
        if (i < maxRetries - 1) {
          await new Promise(resolve => 
            setTimeout(resolve, Math.pow(2, i) * 1000)
          );
        }
      }
    }
    throw lastError;
  }
}

最佳实践建议

1. 错误处理：确保有完善的错误处理和重试机制
2. 超时设置：合理设置请求超时时间
3. 连接池：如果频繁调用，考虑使用连接池
4. 日志记录：记录 OpenClaw 调用的详细日志
5. 监控：集成到应用的监控系统中
6. 配置管理：通过环境变量管理配置

选择哪种集成方式取决于：

• OpenClaw 提供的接口形式（REST、WebSocket、CLI等）
• 性能要求
• 是否需要实时反馈
• 部署架构

标签： OpenClaw集成 js集成