Openqq

{
  "ownerId": "kn73ngf0s02mcqawszh8pgzcmh8140sg",
  "slug": "openqq",
  "version": "0.0.5",
  "publishedAt": 1772090217841
}

{
  "version": 1,
  "registry": "https://clawhub.ai",
  "slug": "openqq",
  "installedVersion": "0.0.5",
  "installedAt": 1776067938937
}

const fs = require('fs');
const path = require('path');

class QQBotLogger {
  constructor(config) {
    this.config = config?.logger || this.getDefaultConfig();
    this.logDir = this.config.logDir;
    this.ensureLogDir();
    
    const dateStr = this.getChinaDate();
    this.logFile = path.join(this.logDir, `qq-bot-${dateStr}.log`);
    this.debugFile = path.join(this.logDir, `qq-bot-${dateStr}-debug.log`);
    
    this.initLogRotation();
  }

  getDefaultConfig() {
    return {
      logDir: '/root/.openclaw/workspace/logs/qq-bot',
      maxLogSize: '10MB',
      maxLogFiles: 7,
      timezone: 'Asia/Shanghai',
      logLevel: 'debug',
      sanitizeSensitive: true
    };
  }

  ensureLogDir() {
    if (!fs.existsSync(this.logDir)) {
      fs.mkdirSync(this.logDir, { recursive: true });
      fs.chmodSync(this.logDir, 0o755);
    }
  }

  getChinaTime() {
    const now = new Date();
    const chinaTime = new Date(now.getTime() + (8 * 60 * 60 * 1000));
    return chinaTime.toISOString().replace('Z', '+08:00');
  }

  getChinaDate() {
    const now = new Date();
    const chinaTime = new Date(now.getTime() + (8 * 60 * 60 * 1000));
    return chinaTime.toISOString().split('T')[0];
  }

  sanitizeMessage(message) {
    if (!this.config.sanitizeSensitive) return message;
    
    return message
      .replace(/(token|password|key|secret)=\w+/gi, '$1=***')
      .replace(/sk-[a-zA-Z0-9]{32}/gi, 'sk-***');
  }

  writeLog(filePath, logStr) {
    fs.appendFile(filePath, logStr + '\n', (err) => {
      if (err) {
        try {
          fs.appendFileSync(filePath, logStr + '\n');
        } catch (syncErr) {
          console.error('Log write failed:', syncErr);
        }
      }
    });
  }

  initLogRotation() {
    this.checkAndRotateLogs();
    setInterval(() => this.checkAndRotateLogs(), 24 * 60 * 60 * 1000);
  }

  checkAndRotateLogs() {
    try {
      const dateStr = this.getChinaDate();
      const files = [
        path.join(this.logDir, `qq-bot-${dateStr}.log`),
        path.join(this.logDir, `qq-bot-${dateStr}-debug.log`)
      ];
      
      const maxSize = this.parseSize(this.config.maxLogSize);
      
      for (const file of files) {
        if (fs.existsSync(file)) {
          const stats = fs.statSync(file);
          if (stats.size > maxSize) {
            this.rotateLogFile(file);
          }
        }
      }
      
      this.cleanupOldLogs();
    } catch (error) {
      console.error('Log rotation check failed:', error);
    }
  }

  parseSize(sizeStr) {
    const units = { 'B': 1, 'KB': 1024, 'MB': 1024*1024, 'GB': 1024*1024*1024 };
    const match = sizeStr.match(/^(\d+)([KMGT]?B?)$/i);
    if (match) {
      const value = parseInt(match[1]);
      const unit = (match[2] || 'B').toUpperCase();
      return value * (units[unit] || 1);
    }
    return 10 * 1024 * 1024;
  }

  rotateLogFile(filePath) {
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const rotatedPath = `${filePath}.${timestamp}`;
    try {
      fs.renameSync(filePath, rotatedPath);
    } catch (error) {
      console.error('Log rotation failed:', error);
    }
  }

  cleanupOldLogs() {
    try {
      const files = fs.readdirSync(this.logDir);
      const logFiles = files.filter(f => 
        f.startsWith('qq-bot-') && (f.endsWith('.log') || f.endsWith('.log.gz'))
      );
      
      logFiles.sort((a, b) => {
        const timeA = fs.statSync(path.join(this.logDir, a)).mtime;
        const timeB = fs.statSync(path.join(this.logDir, b)).mtime;
        return timeB - timeA;
      });
      
      for (let i = this.config.maxLogFiles; i < logFiles.length; i++) {
        fs.unlinkSync(path.join(this.logDir, logFiles[i]));
      }
    } catch (error) {
      console.error('Log cleanup failed:', error);
    }
  }

  shouldLog(level) {
    const levels = { error: 0, info: 1, debug: 2 };
    const current = levels[this.config.logLevel] ?? 2;
    return current >= levels[level];
  }

  log(message, context = {}) {
    if (!this.shouldLog('info')) return;
    
    const timestamp = this.getChinaTime();
    const sanitizedMessage = this.sanitizeMessage(message);
    const logEntry = { timestamp, level: 'INFO', message: sanitizedMessage, ...context };
    
    const logStr = JSON.stringify(logEntry);
    console.log(logStr);
    this.writeLog(this.logFile, logStr);
  }

  debug(message, context = {}) {
    if (!this.shouldLog('debug')) return;
    
    const timestamp = this.getChinaTime();
    const sanitizedMessage = this.sanitizeMessage(message);
    const logEntry = { timestamp, level: 'DEBUG', message: sanitizedMessage, ...context };
    
    const logStr = JSON.stringify(logEntry, null, 2);
    console.log(logStr);
    this.writeLog(this.debugFile, logStr);
  }

  error(message, error = {}) {
    if (!this.shouldLog('error')) return;
    
    const timestamp = this.getChinaTime();
    const sanitizedMessage = this.sanitizeMessage(message);
    const logEntry = {
      timestamp,
      level: 'ERROR',
      message: sanitizedMessage,
      error: { message: error.message, stack: error.stack, code: error.code }
    };
    
    const logStr = JSON.stringify(logEntry, null, 2);
    console.error(logStr);
    this.writeLog(this.debugFile, logStr);
  }

  logOpenClawInteraction(sessionMessage, openclawReply) {
    this.debug('OpenClaw session interaction', {
      sentToOpenClaw: sessionMessage,
      receivedFromOpenClaw: openclawReply
    });
  }

  logApiCall(apiName, params, response) {
    this.debug(`API call: ${apiName}`, {
      requestParams: params,
      responseStatus: response?.status,
      responseData: response?.data
    });
  }
}

module.exports = QQBotLogger;

{
  "name": "openqq",
  "version": "0.0.4",
  "description": "QQ bot integration for OpenClaw with session isolation and logging",
  "main": "qq-bot.js",
  "bin": {
    "openqq": "./qq-bot.js"
  },
  "scripts": {
    "start": "node qq-bot.js",
    "dev": "node --watch qq-bot.js",
    "test": "echo \"No tests specified\" && exit 0",
    "setup": "cp open-qq-config.json.example ~/.openclaw/workspace/open-qq-config.json && echo '✅ Config created! Edit ~/.openclaw/workspace/open-qq-config.json'",
    "install-deps": "npm install",
    "clean": "rm -rf node_modules package-lock.json",
    "logs": "tail -f ../../logs/qq-bot/qq-bot-$(date +%Y-%m-%d).log",
    "status": "pgrep -f 'node qq-bot.js' > /dev/null && echo '✅ Running' || echo '❌ Not running'",
    "health": "bash scripts/health-check.sh",
    "version": "echo \"openqq v$(node -p \"require('./package.json').version\")\"",
    "test-msg": "node -e \"const {spawn}=require('child_process'); const m=process.argv.slice(3).join(' ')||'你好'; const p=spawn('openclaw',['agent','--session-id','qq-test','--message',m]); p.stdout.on('data',d=>console.log(d.toString())); p.stderr.on('data',d=>console.error(d.toString()));\"",
    "restart": "echo '❌ Use systemctl restart qq-bot (if installed as service)'",
    "stop": "echo '❌ Use systemctl stop qq-bot (if installed as service)' || pkill -f 'node qq-bot.js'"
  },
  "keywords": ["qq", "bot", "openclaw", "websocket"],
  "author": "番茄",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://clawhub.com/skills/openqq"
  },
  "dependencies": {
    "axios": "^1.13.5",
    "ws": "^8.19.0"
  },
  "engines": {
    "node": ">=16.0.0"
  }
}

#!/usr/bin/env node

const WebSocket = require('ws');
const axios = require('axios');
const { spawn } = require('child_process');
const fs = require('fs');
const path = require('path');

// 从 workspace 配置文件加载配置
const CONFIG_PATH = path.join(process.env.HOME || '/root', '.openclaw/workspace/open-qq-config.json');

function loadConfig() {
  try {
    if (!fs.existsSync(CONFIG_PATH)) {
      console.error(`❌ 配置文件不存在：${CONFIG_PATH}`);
      console.error('请复制 open-qq-config.json.example 到 ~/.openclaw/workspace/open-qq-config.json 并填写配置');
      process.exit(1);
    }
    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
    
    if (!config.qq?.appId || !config.qq?.token || !config.qq?.appSecret) {
      console.error('❌ 配置文件中缺少必需的 QQ 凭据 (qq.appId, qq.token, qq.appSecret)');
      process.exit(1);
    }
    
    return config;
  } catch (error) {
    console.error('❌ 读取配置文件失败:', error.message);
    process.exit(1);
  }
}

const config = loadConfig();
const QQBotLogger = require('./logger');
const logger = new QQBotLogger(config);

class QQBot {
  constructor(config) {
    this.appId = config.qq.appId;
    this.token = config.qq.token;
    this.appSecret = config.qq.appSecret;
    this.botConfig = config.bot || {};
    this.ws = null;
    this.sessionId = null;
    this.lastSeq = 0;
  }

  async getAccessToken(retryCount = 0) {
    logger.log('Requesting access token from QQ API', { appId: this.appId });
    
    try {
      const response = await axios.post(
        'https://bots.qq.com/app/getAppAccessToken',
        { appId: this.appId, clientSecret: this.appSecret },
        { timeout: 30000 }
      );
      
      logger.log('Access token received successfully', { expiresIn: response.data.expires_in });
      logger.logApiCall('getAppAccessToken', { appId: this.appId }, response);
      
      return response.data.access_token;
    } catch (error) {
      logger.error('Failed to get access token', error);
      
      if (retryCount < 3) {
        logger.log(`Retrying access token request (${retryCount + 1}/3)`);
        await new Promise(resolve => setTimeout(resolve, 2000 * (retryCount + 1)));
        return this.getAccessToken(retryCount + 1);
      }
      
      throw error;
    }
  }

  async sendToOpenClawAndWait(messageData) {
    const message = messageData.content.trim();
    
    logger.log('Sending message to OpenClaw session', {
      userId: messageData.author.id,
      groupId: messageData.group_id || 'direct',
      message,
    });
    
    try {
      const isPrivate = messageData.msg_type === 'private';
      const openId = isPrivate 
        ? messageData.author.user_openid 
        : messageData.group_openid;
      
      let sessionLabel = isPrivate 
        ? `qq-private-${openId}` 
        : `qq-group-${openId}`;
      
      sessionLabel = sessionLabel.replace(/[^a-zA-Z0-9-]/g, '');
      
      const senderId = isPrivate 
        ? (messageData.author.user_openid || 'unknown_user')
        : (messageData.author.member_openid || 'unknown_member');
      
      const senderPrefix = isPrivate 
        ? `[QQ User: ${senderId}] `
        : `[QQ Member: ${senderId}] `;
      
      const messageWithSender = `${senderPrefix}${message}`;
      
      const openclaw = spawn('openclaw', [
        'agent',
        '--session-id', sessionLabel,
        '--message', messageWithSender
      ]);
      
      const stdoutChunks = [];
      const stderrChunks = [];
      
      openclaw.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
      openclaw.stderr.on('data', (chunk) => stderrChunks.push(chunk));
      
      const exitCode = await new Promise((resolve) => {
        openclaw.on('close', resolve);
        openclaw.on('error', () => resolve(1));
      });
      
      const output = Buffer.concat(stdoutChunks).toString().trim();
      const errorOutput = Buffer.concat(stderrChunks).toString().trim();
      
      logger.log('OpenClaw raw output', {
        outputLength: output.length,
        errorLength: errorOutput.length,
        exitCode
      });
      
      // 处理回复
      let openclawReply = output || errorOutput;
      openclawReply = openclawReply.replace(/^```[\s\S]*?\n/, '').replace(/```$/, '').trim();
      
      if (!openclawReply || openclawReply.trim() === '') {
        openclawReply = '🤖 抱歉，机器人没有返回内容！';
      }
      
      logger.log('OpenClaw reply received', {
        replyLength: openclawReply.length,
        sessionLabel,
        exitCode
      });
      
      logger.logOpenClawInteraction(messageWithSender, openclawReply);
      
      return openclawReply;
    } catch (error) {
      logger.error('OpenClaw session failed', { error: error.message });
      return '🤖 抱歉，机器人处理消息时出错了！请稍后再试。';
    }
  }

  async sendReply(messageData, content, retryCount = 0) {
    try {
      const accessToken = await this.getAccessToken();
      const isGroup = messageData.msg_type === 'group';
      
      logger.log('Sending reply to QQ', {
        content,
        target: isGroup ? `group:${messageData.group_id}` : `user:${messageData.author.id}`
      });
      
      const url = isGroup
        ? `https://api.sgroup.qq.com/v2/groups/${messageData.group_id}/messages`
        : `https://api.sgroup.qq.com/v2/users/${messageData.author.id}/messages`;
      
      const body = isGroup
        ? { content, msg_id: messageData.id }
        : { content };
      
      const response = await axios.post(url, body, {
        headers: {
          'Authorization': `QQBot ${accessToken}`,
          'Content-Type': 'application/json'
        },
        timeout: 10000
      });
      
      logger.log(`${isGroup ? 'Group' : 'Private'} reply sent successfully`, {
        [isGroup ? 'groupId' : 'userId']: isGroup ? messageData.group_id : messageData.author.id,
        messageId: response.data?.id
      });
      
      logger.logApiCall('sendMessage', {
        target: isGroup ? `group:${messageData.group_id}` : `user:${messageData.author.id}`,
        content
      }, response);
      
    } catch (error) {
      if (retryCount < 2) {
        logger.log(`Retrying message send (${retryCount + 1}/2)`);
        await new Promise(resolve => setTimeout(resolve, 1000 * (retryCount + 1)));
        return this.sendReply(messageData, content, retryCount + 1);
      }
      
      logger.error('Failed to send reply to QQ after retries', error);
    }
  }

  async handleMessage(event) {
    const isPrivate = event.t === 'C2C_MESSAGE_CREATE';
    const isGroupAt = event.t === 'GROUP_AT_MESSAGE_CREATE';
    
    if (!isPrivate && !isGroupAt) {
      logger.log('Unhandled event type', { eventType: event.t });
      return;
    }
    
    // 记录消息
    const msgData = event.d;
    logger.log(`${isPrivate ? 'Private' : 'Group @'} message received from QQ`, {
      eventType: event.t,
      messageId: msgData.id,
      content: msgData.content,
      authorId: isPrivate ? msgData.author.user_openid : msgData.author.member_openid,
      ...(isGroupAt && { groupId: msgData.group_openid }),
      timestamp: msgData.timestamp
    });
    
    // 标记消息类型
    msgData.msg_type = isPrivate ? 'private' : 'group';
    if (isPrivate) {
      msgData.author.id = msgData.author.user_openid;
    } else {
      msgData.group_id = msgData.group_openid;
    }
    
    // 获取回复并发送
    const reply = await this.sendToOpenClawAndWait(msgData);
    await this.sendReply(msgData, reply);
  }

  async connect() {
    const accessToken = await this.getAccessToken();
    
    // 获取 WebSocket 连接参数
    const wsParams = await axios.get('https://api.sgroup.qq.com/gateway/bot', {
      headers: { 'Authorization': `QQBot ${accessToken}` }
    });
    
    const wsUrl = `${wsParams.data.url}?compress=0`;
    console.log('🔗 Connecting to QQ WebSocket:', wsUrl);
    
    this.ws = new WebSocket(wsUrl);
    
    this.ws.on('open', () => {
      console.log('✅ WebSocket connected');
    });
    
    this.ws.on('message', async (data) => {
      const event = JSON.parse(data);
      logger.log('Received WebSocket message', { 
        op: event.op, 
        t: event.t,
        hasD: !!event.d,
        dKeys: event.d ? Object.keys(event.d) : []
      });
      
      // HELLO 事件
      if (event.op === 10) {
        this.sessionId = event.d.session_id;
        this.lastSeq = 0;
        logger.log('Received HELLO event from QQ gateway', {
          sessionId: this.sessionId,
          lastSeq: this.lastSeq
        });
        
        this.ws.send(JSON.stringify({
          op: 2, // IDENTIFY
          d: {
            token: `QQBot ${accessToken}`,
            intents: (1 << 0) | (1 << 25), // 私域完整权限
            shard: [0, 1],
            properties: { os: 'linux', browser: 'openclaw' }
          }
        }));
        logger.log('Sent IDENTIFY payload to QQ gateway');
        
      } else if (event.op === 11) {
        // HEARTBEAT ACK
        logger.log('Heartbeat ACK received from QQ gateway');
        
      } else if (event.op === 0 && event.t) {
        // 消息事件
        await this.handleMessage(event);
        
      } else {
        // 其他事件
        logger.log('Non-message event received', { op: event.op, t: event.t });
      }
    });
    
    this.ws.on('error', (error) => {
      logger.error('WebSocket error', error);
    });
    
    this.ws.on('close', (code, reason) => {
      console.log(`❌ WebSocket disconnected (code: ${code}), reconnecting...`);
      logger.log('WebSocket disconnected', { code, reason: reason?.toString() });
      setTimeout(() => this.connect(), this.botConfig.reconnectDelay || 5000);
    });
    
    // 启动心跳
    const heartbeatInterval = this.botConfig.heartbeatInterval || 30000;
    this.heartbeatInterval = setInterval(() => {
      if (this.ws.readyState === WebSocket.OPEN) {
        this.ws.send(JSON.stringify({ op: 1, d: this.lastSeq }));
        console.log('💓 Sending heartbeat');
      }
    }, heartbeatInterval);
    
    // 启动完成提示
    console.log('');
    console.log('✅ QQ Bot 已就绪，可以接收消息了！');
    console.log('');
    logger.log('QQ Bot started successfully', {
      appId: this.appId,
      heartbeatInterval,
      reconnectDelay: this.botConfig.reconnectDelay || 5000
    });
  }
}

// 启动机器人
console.log('🚀 正在启动 QQ Bot...');
const bot = new QQBot(config);
bot.connect().catch((error) => {
  console.error('❌ 启动失败:', error.message);
  process.exit(1);
});

// 优雅关闭处理
let isShuttingDown = false;

process.on('SIGTERM', handleShutdown);
process.on('SIGINT', handleShutdown);

async function handleShutdown() {
  if (isShuttingDown) return;
  isShuttingDown = true;
  
  console.log('');
  console.log('🛑 正在关闭 QQ Bot...');
  logger.log('Shutting down QQ Bot');
  
  // 关闭 WebSocket 连接
  if (bot.ws) {
    bot.ws.removeAllListeners('close');
    bot.ws.close();
  }
  
  // 停止心跳
  if (bot.heartbeatInterval) {
    clearInterval(bot.heartbeatInterval);
  }
  
  // 等待一下确保连接关闭
  await new Promise(resolve => setTimeout(resolve, 1000));
  
  console.log('✅ QQ Bot 已关闭');
  logger.log('QQ Bot shutdown complete');
  process.exit(0);
}

#!/bin/bash

# QQ Bot 健康检查脚本

LOG_DIR="$HOME/.openclaw/workspace/logs/qq-bot"
TODAY=$(date +%Y-%m-%d)
LOG_FILE="$LOG_DIR/qq-bot-$TODAY.log"

echo "🔍 QQ Bot 健康检查"
echo "=================="

# 检查进程
if pgrep -f "node qq-bot.js" > /dev/null; then
  echo "✅ 进程状态：运行中"
else
  echo "❌ 进程状态：未运行"
  exit 1
fi

# 检查日志文件
if [ -f "$LOG_FILE" ]; then
  echo "✅ 日志文件：存在"
  
  # 检查最近 5 分钟是否有日志
  if find "$LOG_FILE" -mmin -5 2>/dev/null | grep -q .; then
    echo "✅ 日志更新：正常"
  else
    echo "⚠️  日志更新：可能停滞"
  fi
  
  # 检查最近的错误
  ERRORS=$(tail -100 "$LOG_FILE" 2>/dev/null | grep -c "ERROR" || true)
  ERRORS=${ERRORS:-0}
  if [ "$ERRORS" -gt 0 ] 2>/dev/null; then
    echo "⚠️  最近错误：$ERRORS 条"
  else
    echo "✅ 最近错误：无"
  fi
else
  echo "❌ 日志文件：不存在"
fi

# 检查配置文件
CONFIG_FILE="$HOME/.openclaw/workspace/open-qq-config.json"
if [ -f "$CONFIG_FILE" ]; then
  echo "✅ 配置文件：存在"
else
  echo "❌ 配置文件：不存在"
  exit 1
fi

echo "=================="
echo "✅ 健康检查完成"

#!/bin/bash

CONFIG_FILE="$HOME/.openclaw/workspace/open-qq-config.json"

if [ ! -f "$CONFIG_FILE" ]; then
  echo "❌ 配置文件不存在：$CONFIG_FILE"
  exit 1
fi

cd /root/.openclaw/workspace/skills/openqq
echo "🚀 Starting QQ Bot..."
node qq-bot.js