Wecom Automation

#!/usr/bin/env node
/**
 * 企业微信个人账号机器人 - 主文件
 * 基于 Wechaty + PadLocal
 */

require('dotenv').config({ path: __dirname + '/.env' });
const { Wechaty } = require('wechaty');
const { PuppetPadlocal } = require('wechaty-puppet-padlocal');
const winston = require('winston');

// 导入工作流
const {
  handleFriendAdd,
  handleRoomJoin,
  handleRoomLeave
} = require('./workflows/on_event');
const {
  handleTextMessage,
  handleFileMessage,
  handleImageMessage,
  handleVoiceMessage
} = require('./workflows/handle_message');

// 日志配置
const logger = winston.createLogger({
  level: process.env.WECHATY_LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.printf(({ timestamp, level, message }) => {
      return `[${timestamp}] ${level.toUpperCase()}: ${message}`;
    })
  ),
  transports: [
    new winston.transports.Console(),
    new winston.transports.File({
      filename: __dirname + '/logs/error.log',
      level: 'error'
    }),
    new winston.transports.File({
      filename: __dirname + '/logs/combined.log'
    })
  ]
});

// 创建 Wechaty 实例
const bot = new Wechaty({
  name: process.env.WECOM_NAME || 'WeCom-Bot',
  puppet: new PuppetPadlocal({
    token: process.env.WECHATY_TOKEN,
  }),
  puppetOptions: {
    uos: true, // 使用 uos 协议
  },
});

/**
 * 启动机器人
 */
async function startBot() {
  logger.info('🤖 正在启动机器人...');

  try {
    // 事件监听
    bot.on('scan', onScan);
    bot.on('login', onLogin);
    bot.on('logout', onLogout);
    bot.on('friendship', onFriendship);
    bot.on('room-join', onRoomJoin);
    bot.on('room-leave', onRoomLeave);
    bot.on('message', onMessage);

    // 启动
    await bot.start();
    logger.info('✅ 机器人已启动');

  } catch (error) {
    logger.error(`❌ 启动失败: ${error.message}`);
    process.exit(1);
  }
}

/**
 * 扫码登录事件
 */
function onScan(qrcode, status) {
  if (status === 2 || status === 3) {
    require('qrcode-terminal').generate(qrcode, { small: true });
    logger.info(`[${status === 2 ? '扫描中' : '已扫描'}] 请使用企业微信扫描二维码登录`);
    logger.info(`或访问 https://wechaty.js.org/qrcode/${qrcode}`);
  }
}

/**
 * 登录成功事件
 */
async function onLogin(user) {
  logger.info(`✅ 登录成功: ${user.name()} (${user.id})`);

  // 发送启动通知到管理员
  if (process.env.ADMIN_WECHATY_NAME) {
    const admin = await bot.Contact.find({ name: process.env.ADMIN_WECHATY_NAME });
    if (admin) {
      await admin.say('🤖 机器人已启动，随时为您服务！');
    }
  }
}

/**
 * 登出事件
 */
function onLogout(user) {
  logger.info(`👋 登出: ${user.name()} (${user.id})`);
}

/**
 * 好友关系事件
 */
async function onFriendship(friendship) {
  logger.info(`👥 好友事件: ${friendship.type()}`);

  switch (friendship.type()) {
    case bot.Friendship.Type.Receive:
      // 收到好友请求
      await handleFriendAdd(friendship);
      break;

    case bot.Friendship.Type.Confirm:
      // 好友关系确认
      logger.info('✅ 好友关系已确认');
      break;

    default:
      logger.debug(`其他好友事件: ${friendship.type()}`);
  }
}

/**
 * 进群事件
 */
async function onRoomJoin(room, inviteeList, inviter) {
  logger.info(`🚪 进群事件: ${room.topic()}`);

  try {
    await handleRoomJoin(room, inviteeList, inviter);
  } catch (error) {
    logger.error(`处理进群事件失败: ${error.message}`);
  }
}

/**
 * 退群事件
 */
async function onRoomLeave(room, leaverList) {
  logger.info(`🚪 退群事件: ${room.topic()}`);

  try {
    await handleRoomLeave(room, leaverList);
  } catch (error) {
    logger.error(`处理退群事件失败: ${error.message}`);
  }
}

/**
 * 消息事件
 */
async function onMessage(msg) {
  try {
    const from = msg.from();
    const room = msg.room();
    const text = msg.text();
    const type = msg.type();

    // 忽略自己发的消息
    if (msg.self()) {
      return;
    }

    // 记录消息
    if (room) {
      logger.info(`📨 [群聊 ${room.topic()}] ${from ? from.name() : '未知'}: ${text}`);
    } else {
      logger.info(`📨 [私聊] ${from ? from.name() : '未知'}: ${text}`);
    }

    // 路由处理
    switch (type) {
      case bot.Message.Type.Text:
        await handleTextMessage(msg);
        break;

      case bot.Message.Type.Attachment:
      case bot.Message.Type.Video:
      case bot.Message.Type.Audio:
        await handleFileMessage(msg);
        break;

      case bot.Message.Type.Image:
        await handleImageMessage(msg);
        break;

      case bot.Message.Type.Url:
        await handleUrlMessage(msg);
        break;

      case bot.Message.Type.MiniProgram:
        await handleMiniProgram(msg);
        break;

      default:
        logger.debug(`未处理的消息类型: ${type}`);
    }

  } catch (error) {
    logger.error(`处理消息失败: ${error.message}`);
    await msg.say('😔 处理消息时遇到错误，请稍后再试');
  }
}

/**
 * 处理 URL 消息
 */
async function handleUrlMessage(msg) {
  const urlLink = await msg.toUrlLink();
  logger.info(`🔗 URL: ${urlLink.url()} - ${urlLink.title()}`);

  // 可以进一步处理 URL 内容
  await msg.say(`✅ 已收到链接：${urlLink.title()}`);
}

/**
 * 处理小程序消息
 */
async function handleMiniProgram(msg) {
  const miniProgram = await msg.toMiniProgram();
  logger.info(`📱 小程序: ${miniProgram.appid()}`);

  await msg.say('✅ 已收到小程序消息');
}

// 异常处理
process.on('unhandledRejection', (reason, promise) => {
  logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
});

// 启动机器人
startBot();

module.exports = {
  apps: [{
    name: 'wecom-bot',
    script: './bot.js',
    cwd: '/home/aa/clawd/skills/wecom-automation',
    interpreter: 'node',
    instances: 1,
    autorestart: true,
    watch: false,
    max_memory_restart: '500M',
    env: {
      NODE_ENV: 'production',
      WECHATY_LOG_LEVEL: 'info'
    },
    error_file: './logs/error.log',
    out_file: './logs/out.log',
    log_date_format: 'YYYY-MM-DD HH:mm:ss Z',
    merge_logs: true,
    autorestart: true,
    max_restarts: 10,
    min_uptime: '10s'
  }]
};

#!/bin/bash
# 企业微信个人账号机器人 - 一键安装脚本

set -e

echo "🚀 开始安装企业微信个人账号机器人..."
echo ""

# 颜色定义
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
NC='\033[0m' # No Color

# 检查依赖
check_dependencies() {
    echo -e "${YELLOW}检查系统依赖...${NC}"

    # Node.js
    if ! command -v node &> /dev/null; then
        echo -e "${RED}❌ 未安装 Node.js${NC}"
        echo "请安装 Node.js 16+：curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -"
        exit 1
    fi

    # npm
    if ! command -v npm &> /dev/null; then
        echo -e "${RED}❌ 未安装 npm${NC}"
        exit 1
    fi

    # Python 3
    if ! command -v python3 &> /dev/null; then
        echo -e "${RED}❌ 未安装 Python 3${NC}"
        exit 1
    fi

    # pip
    if ! command -v pip3 &> /dev/null; then
        echo -e "${RED}❌ 未安装 pip3${NC}"
        exit 1
    fi

    # PostgreSQL
    if ! command -v psql &> /dev/null; then
        echo -e "${YELLOW}⚠️  未安装 PostgreSQL，正在安装...${NC}"
        sudo apt update
        sudo apt install -y postgresql postgresql-contrib
    fi

    echo -e "${GREEN}✓ 依赖检查完成${NC}"
    echo ""
}

# 安装 Node.js 依赖
install_node_packages() {
    echo -e "${YELLOW}安装 Node.js 依赖...${NC}"

    cd ~/clawd/skills/wecom-automation

    npm install || {
        echo -e "${RED}❌ Node.js 包安装失败${NC}"
        exit 1
    }

    echo -e "${GREEN}✓ Node.js 包安装完成${NC}"
    echo ""
}

# 安装 Python 包
install_python_packages() {
    echo -e "${YELLOW}安装 Python 依赖...${NC}"

    pip3 install --user -r requirements.txt || {
        echo -e "${RED}❌ Python 包安装失败${NC}"
        exit 1
    }

    echo -e "${GREEN}✓ Python 包安装完成${NC}"
    echo ""
}

# 配置数据库
setup_database() {
    echo -e "${YELLOW}配置数据库...${NC}"

    # 启动 PostgreSQL
    sudo service postgresql start

    # 创建数据库
    sudo -u postgres createdb wecom_kb 2>/dev/null || echo "数据库已存在"

    # 启用 pgvector 扩展
    echo -e "${YELLOW}检查 pgvector 扩展...${NC}"

    if ! sudo -u postgres psql -d wecom_kb -c "SELECT * FROM pg_extension WHERE extname = 'vector';" | grep -q vector; then
        echo -e "${YELLOW}安装 pgvector...${NC}"

        # 检测 PostgreSQL 版本
        PG_VERSION=$(sudo -u postgres psql -t -c "SELECT version()" | grep -oP 'PostgreSQL \K[0-9.]+' | head -1)
        PG_MAJOR=$(echo $PG_VERSION | cut -d. -f1)

        echo "检测到 PostgreSQL $PG_VERSION"

        # 安装 pgvector
        if [ ! -d "/tmp/pgvector" ]; then
            cd /tmp
            git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
            cd pgvector
            sudo apt install -y build-essential libpq-dev
            make
            sudo make install
        fi

        # 启用扩展
        sudo -u postgres psql -d wecom_kb -c "CREATE EXTENSION vector;"
        echo -e "${GREEN}✓ pgvector 扩展已启用${NC}"
    else
        echo -e "${GREEN}✓ pgvector 扩展已存在${NC}"
    fi

    # 初始化表结构
    echo -e "${YELLOW}初始化数据库表...${NC}"
    sudo -u postgres psql -d wecom_kb -f schema.sql

    echo -e "${GREEN}✓ 数据库配置完成${NC}"
    echo ""
}

# 配置环境变量
setup_env() {
    echo -e "${YELLOW}配置环境变量...${NC}"

    ENV_FILE="$HOME/clawd/skills/wecom-automation/.env"

    if [ -f "$ENV_FILE" ]; then
        echo -e "${YELLOW}⚠️  .env 文件已存在，跳过${NC}"
    else
        cp .env.example "$ENV_FILE"
        
        # 自动填入 Kimi API Key
        if pass show api/kimi &> /dev/null; then
            sed -i "s|LLM_API_KEY=.*|LLM_API_KEY=$(pass show api/kimi)|" "$ENV_FILE"
        fi

        echo -e "${GREEN}✓ 已创建 .env 模板${NC}"
        echo -e "${YELLOW}⚠️  请编辑 $ENV_FILE 填入以下配置：${NC}"
        echo ""
        echo "必填项："
        echo "  1. WECHATY_TOKEN - PadLocal Token (https://github.com/wechaty/puppet-service)"
        echo "  2. TELEGRAM_BOT_TOKEN - 用于人工介入通知"
        echo ""
        echo "可选项（已自动填入）："
        echo "  3. LLM_API_KEY - Kimi API Key (已自动配置)"
    fi

    echo ""
}

# 创建必要目录
setup_directories() {
    echo -e "${YELLOW}创建必要目录...${NC}"

    mkdir -p logs
    mkdir -p tmp
    
    echo -e "${GREEN}✓ 目录创建完成${NC}"
    echo ""
}

# 导入示例知识库
import_sample_kb() {
    echo -e "${YELLOW}导入示例知识库...${NC}"

    KB_FILE="$HOME/clawd/skills/wecom-automation/knowledge/sample.md"

    if [ -f "$KB_FILE" ]; then
        python3 scripts/import_kb.py \
            --input "$KB_FILE" \
            --category "示例知识" \
            --tags "示例,测试" \
            --key "$(pass show api/kimi)" || {
            echo -e "${RED}❌ 知识库导入失败（可能需要先配置 Kimi API Key）${NC}"
            echo "可以稍后手动导入："
            echo "python3 ~/clawd/skills/wecom-automation/scripts/import_kb.py --input knowledge/sample.md --key YOUR_KIMI_KEY"
        }
        echo -e "${GREEN}✓ 知识库导入完成${NC}"
    else
        echo -e "${YELLOW}⚠️  示例知识库文件不存在${NC}"
    fi

    echo ""
}

# 打印后续步骤
print_next_steps() {
    echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${GREEN}✅ 安装完成！${NC}"
    echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo ""
    echo "📋 后续步骤："
    echo ""
    echo "1️⃣  申请 PadLocal Token"
    echo "   - 访问 https://github.com/wechaty/wechaty"
    echo "   - 选择 PadLocal 协议"
    echo "   - 注册并获取 Token"
    echo ""
    echo "2️⃣  填写环境变量"
    echo "   - 编辑 ~/clawd/skills/wecom-automation/.env"
    echo "   - 填入 WECHATY_TOKEN"
    echo "   - 填入 TELEGRAM_BOT_TOKEN"
    echo ""
    echo "3️⃣  启动机器人"
    echo "   cd ~/clawd/skills/wecom-automation"
    echo "   npm start"
    echo ""
    echo "   或使用 PM2（推荐）："
    echo "   pm2 start ecosystem.config.js"
    echo ""
    echo "4️⃣  扫码登录"
    echo "   - 启动后会显示二维码"
    echo "   - 打开企业微信 → 扫一扫"
    echo "   - 扫描二维码登录"
    echo ""
    echo "5️⃣  测试功能"
    echo "   # 测试问答"
    echo "   python3 ~/clawd/skills/wecom-automation/workflows/answer_question.py \\"
    echo "     --user-id test_user --question \"如何退款？\""
    echo ""
    echo "   # 测试人工介入"
    echo "   python3 ~/clawd/skills/wecom-automation/workflows/escalate.py \\"
    echo "     --user-id test_user --name \"测试用户\" --question \"测试问题\""
    echo ""
    echo "📚 更多信息："
    echo "   cat ~/clawd/skills/wecom-automation/SKILL.md"
    echo ""
}

# 主流程
main() {
    check_dependencies
    install_node_packages
    install_python_packages
    setup_database
    setup_env
    setup_directories
    import_sample_kb
    print_next_steps
}

# 运行安装
main

{
  "name": "wecom-automation",
  "version": "1.0.0",
  "description": "企业微信个人账号直连自动化 - 基于 Wechaty",
  "main": "bot.js",
  "scripts": {
    "start": "node bot.js",
    "dev": "node --watch bot.js",
    "test": "node test/test.js"
  },
  "keywords": [
    "wechaty",
    "wecom",
    "bot",
    "automation"
  ],
  "author": "OpenClaw",
  "license": "MIT",
  "dependencies": {
    "wechaty": "^1.20.2",
    "wechaty-puppet-padlocal": "^1.0.0",
    "wechaty-puppet-service": "^1.0.0",
    "dotenv": "^16.3.1",
    "axios": "^1.6.0",
    "pg": "^8.11.3",
    "node-schedule": "^2.1.1",
    "winston": "^3.11.0"
  },
  "devDependencies": {
    "nodemon": "^3.0.1"
  },
  "engines": {
    "node": ">=16.0.0"
  }
}

# Python 依赖

# LLM
openai>=1.0.0

# 数据库
psycopg2-binary>=2.9.9
pgvector>=0.2.4

# HTTP 请求
requests>=2.31.0

# 文件处理
python-docx>=1.1.0
PyPDF2>=3.0.1
pdfplumber>=0.10.3

# 图片处理
Pillow>=10.1.0

# 环境变量
python-dotenv>=1.0.0

# 日志
colorlog>=6.8.0

/**
 * 消息处理工作流
 */

const { spawn } = require('child_process');
const path = require('path');

/**
 * 处理文本消息（核心问答逻辑）
 */
async function handleTextMessage(msg) {
  const from = msg.from();
  const room = msg.room();
  const text = msg.text();

  try {
    // 调用 Python 问答处理
    const result = await runPythonScript('answer_question.py', [
      '--user-id', from.id,
      '--user-name', from.name(),
      '--question', text,
      ...(room ? ['--room-name', room.topic()] : [])
    ]);

    // 发送回复
    if (result.success) {
      if (result.escalated) {
        // 已转人工，发送提示
        await msg.say(result.answer);
      } else {
        // 自动回复
        await msg.say(result.answer);
      }
    } else {
      throw new Error('问答处理失败');
    }

  } catch (error) {
    console.error('处理文本消息失败:', error);
    await msg.say('😔 处理消息时遇到错误，已为您转接人工客服');
    await escalateToHuman(from, text, error.message);
  }
}

/**
 * 处理文件消息
 */
async function handleFileMessage(msg) {
  const from = msg.from();
  const fileBox = await msg.toFileBox();

  try {
    // 下载文件
    const fileName = fileBox.name;
    const filePath = path.join(__dirname, '../tmp', fileName);

    await fileBox.toFile(filePath);
    console.log(`文件已保存: ${filePath}`);

    // 发送确认
    await msg.say(`✅ 已收到文件：${fileName}\n\n正在处理，请稍候...`);

    // 调用 Python 处理文件
    const result = await runPythonScript('process_file.py', [
      '--file-path', filePath,
      '--user-id', from.id,
      '--user-name', from.name()
    ]);

    if (result.success) {
      await msg.say(result.answer);
    } else {
      throw new Error(result.error || '文件处理失败');
    }

  } catch (error) {
    console.error('处理文件失败:', error);
    await msg.say(`😔 文件处理失败：${error.message}\n\n已为您转接人工客服`);
  }
}

/**
 * 处理图片消息
 */
async function handleImageMessage(msg) {
  const from = msg.from();
  const fileBox = await msg.toFileBox();

  try {
    // 下载图片
    const fileName = `image_${Date.now()}.png`;
    const filePath = path.join(__dirname, '../tmp', fileName);

    await fileBox.toFile(filePath);
    console.log(`图片已保存: ${filePath}`);

    await msg.say('📸 正在识别图片内容...');

    // 调用 Python OCR
    const result = await runPythonScript('ocr_image.py', [
      '--image-path', filePath,
      '--user-id', from.id
    ]);

    if (result.success && result.text) {
      await msg.say(`识别结果：\n\n${result.text}`);
    } else {
      await msg.say('😔 无法识别图片内容，已为您转接人工客服');
    }

  } catch (error) {
    console.error('处理图片失败:', error);
    await msg.say('😔 图片处理失败，已为您转接人工客服');
  }
}

/**
 * 处理语音消息
 */
async function handleVoiceMessage(msg) {
  const from = msg.from();
  const fileBox = await msg.toFileBox();

  try {
    // 下载语音
    const fileName = `voice_${Date.now()}.sil`;
    const filePath = path.join(__dirname, '../tmp', fileName);

    await fileBox.toFile(filePath);
    console.log(`语音已保存: ${filePath}`);

    await msg.say('🎤 正在转换语音为文字...');

    // 调用 Python 语音识别
    const result = await runPythonScript('transcribe_voice.py', [
      '--voice-path', filePath,
      '--user-id', from.id
    ]);

    if (result.success && result.text) {
      await msg.say(`识别结果：\n\n${result.text}`);

      // 如果识别出文字，可以继续走问答流程
      await handleTextMessage({
        from: () => from,
        text: () => result.text,
        say: async (text) => msg.say(text)
      });
    } else {
      await msg.say('😔 无法识别语音内容，已为您转接人工客服');
    }

  } catch (error) {
    console.error('处理语音失败:', error);
    await msg.say('😔 语音处理失败，已为您转接人工客服');
  }
}

/**
 * 辅助函数：运行 Python 脚本
 */
function runPythonScript(scriptName, args = []) {
  return new Promise((resolve, reject) => {
    const scriptPath = path.join(__dirname, '..', 'workflows', scriptName);

    const python = spawn('python3', [scriptPath, ...args], {
      env: {
        ...process.env,
        PYTHONPATH: path.join(__dirname, '..')
      }
    });

    let stdout = '';
    let stderr = '';

    python.stdout.on('data', (data) => {
      stdout += data.toString();
    });

    python.stderr.on('data', (data) => {
      stderr += data.toString();
    });

    python.on('close', (code) => {
      if (code === 0) {
        try {
          const result = JSON.parse(stdout);
          resolve(result);
        } catch (error) {
          reject(new Error(`解析输出失败: ${stdout}`));
        }
      } else {
        reject(new Error(`脚本执行失败: ${stderr}`));
      }
    });

    python.on('error', (error) => {
      reject(error);
    });
  });
}

/**
 * 辅助函数：转人工客服
 */
async function escalateToHuman(contact, question, reason = '') {
  const result = await runPythonScript('escalate.py', [
    '--user-id', contact.id,
    '--name', contact.name(),
    '--question', question,
    '--reason', reason
  ]);

  return result.success;
}

module.exports = {
  handleTextMessage,
  handleFileMessage,
  handleImageMessage,
  handleVoiceMessage
};

/**
 * 事件处理工作流
 * 好友添加、进群、退群等
 */

const { spawn } = require('child_process');
const path = require('path');

/**
 * 处理好友添加
 */
async function handleFriendAdd(friendship) {
  const contact = friendship.contact();

  try {
    console.log(`收到好友请求: ${contact.name()} (${contact.id})`);
    console.log(`验证信息: ${friendship.hello()}`);

    // 自动通过好友请求
    await friendship.accept();
    console.log('✅ 已通过好友请求');

    // 等待一下，确保好友关系建立
    await new Promise(resolve => setTimeout(resolve, 1000));

    // 发送欢迎消息
    const welcomeMsg = `👋 欢迎来到${contact.name()}！

我是智能助手小a 🤖，可以帮您：

📋 查询订单状态
❓ 解答常见问题
🔄 处理售后问题
📁 处理文件（DOCX、PDF等）
🖼️ 图片识别（OCR）
🎤 语音转文字

如需帮助，请直接发送消息或文件。
如有复杂问题，我会自动转接人工客服为您服务。

💡 提示：您可以随时发送"帮助"查看更多功能`;

    await contact.say(welcomeMsg);
    console.log('✅ 已发送欢迎消息');

    // 调用 Python 脚本保存用户信息
    await saveUser(contact);

    // 发送通知给管理员
    await notifyAdmin(`🆕 新好友：${contact.name()} (${contact.id})`);

  } catch (error) {
    console.error('处理好友添加失败:', error);
  }
}

/**
 * 处理进群事件
 */
async function handleRoomJoin(room, inviteeList, inviter) {
  const topic = room.topic();
  const inviterName = inviter ? inviter.name() : '未知';

  console.log(`🚪 进群事件: ${topic}`);
  console.log(`邀请人: ${inviterName}`);

  try {
    // 欢迎新成员
    for (const invitee of inviteeList) {
      await room.say(`👋 欢迎 ${invitee.name()} 加入群聊！`, invitee);
      console.log(`✅ 已欢迎 ${invitee.name()}`);
    }

    // 发送群聊功能说明
    await room.say(`我是智能助手小a 🤖，可以在群聊中帮您：

• 回答常见问题
• 识别图片内容
• 处理文档文件

@我即可使用，或直接在群内提问`);

  } catch (error) {
    console.error('处理进群事件失败:', error);
  }
}

/**
 * 处理退群事件
 */
async function handleRoomLeave(room, leaverList) {
  const topic = room.topic();

  console.log(`🚪 退群事件: ${topic}`);

  for (const leaver of leaverList) {
    console.log(`成员退出: ${leaver.name()}`);

    // 记录退群日志
    await logEvent('room_leave', {
      room: topic,
      user: leaver.name(),
      user_id: leaver.id,
      timestamp: new Date().toISOString()
    });
  }
}

/**
 * 保存用户到数据库
 */
async function saveUser(contact) {
  return runPythonScript('save_user.py', [
    '--user-id', contact.id,
    '--name', contact.name(),
    '--avatar', await contact.avatar() || '',
    '--source', 'we_com'
  ]);
}

/**
 * 通知管理员
 */
async function notifyAdmin(message) {
  // 通过 Telegram 通知
  return runPythonScript('notify_admin.py', [
    '--message', message
  ]);
}

/**
 * 记录事件
 */
async function logEvent(eventType, data) {
  return runPythonScript('log_event.py', [
    '--event-type', eventType,
    '--data', JSON.stringify(data)
  ]);
}

/**
 * 运行 Python 脚本
 */
function runPythonScript(scriptName, args = []) {
  return new Promise((resolve, reject) => {
    const scriptPath = path.join(__dirname, '..', 'workflows', scriptName);

    const python = spawn('python3', [scriptPath, ...args], {
      env: {
        ...process.env,
        PYTHONPATH: path.join(__dirname, '..')
      }
    });

    let stdout = '';
    let stderr = '';

    python.stdout.on('data', (data) => {
      stdout += data.toString();
    });

    python.stderr.on('data', (data) => {
      stderr += data.toString();
    });

    python.on('close', (code) => {
      if (code === 0) {
        try {
          const result = JSON.parse(stdout);
          resolve(result);
        } catch (error) {
          resolve({ success: true, data: stdout });
        }
      } else {
        reject(new Error(`脚本执行失败: ${stderr}`));
      }
    });

    python.on('error', (error) => {
      reject(error);
    });
  });
}

module.exports = {
  handleFriendAdd,
  handleRoomJoin,
  handleRoomLeave
};