Agency problem

[2494911084]

Hello, is there any impact on the server environment? The server IP I am using may be blocked. Sending messages and logging in with QR code are normal, but I am unable to obtain event data. The log shows that the server has been reconnecting to the line. Is the SOCKT5 proxy with account and password configured available? Failed to obtain QR code after configuration

[2494911084]

// LineJS API服务主入口

import express from 'express';
import cors from 'cors';
import { loginWithQR, loginWithAuthToken, loginWithPassword } from '@evex/linejs';
import { FileStorage } from '@evex/linejs/storage';
import rateLimit from 'express-rate-limit';
import fetch from 'node-fetch';
import { SocksProxyAgent } from 'socks-proxy-agent';
import { config, log, errorLog } from './config.js';
// 创建代理 agent
const proxyAgent = new SocksProxyAgent('socks5://username:password@ip:port');

// 自定义 fetch 函数
const customFetch = async (input, init = {}) => {
if (typeof input === 'string') {
// 字符串 URL 格式
return fetch(input, {
...init,
agent: proxyAgent
});
} else {
// Request 对象格式
// 从 Request 对象中提取信息，然后使用普通的 fetch 调用
const url = input.url;
const options = {
method: input.method,
headers: input.headers,
body: input.body,
signal: input.signal,
duplex: init.duplex,
agent: proxyAgent
};
return fetch(url, options);
}
};

// API密钥，实际环境中应从环境变量获取
const API_KEY = process.env.API_KEY || '123456789';

// 请求速率限制配置
const limiter = rateLimit({
windowMs: 15 * 60 * 1000, // 15分钟
max: 100, // 每个IP最多100个请求
message: { code: -429, message: '请求过于频繁，请稍后重试' }
});

// API密钥认证中间件
const apiKeyAuth = (req, res, next) => {
const apiKey = req.headers['x-api-key'];
if (apiKey && apiKey === API_KEY) {
next();
} else {
res.status(401).json({ code: -401, message: '未授权访问' });
}
};

// 统一错误响应处理
const handleError = (res, error, context) => {
errorLog(${context}:, error.message);
errorLog(${context}堆栈:, error.stack);
res.status(500).json({
code: -500,
message: 服务器内部错误 - ${context},
error: error.message
});
};

// 创建Express应用
const app = express();
app.use(cors());
app.use(express.json());
app.use(limiter); // 添加速率限制
app.use('/api/line/*', apiKeyAuth); // API密钥认证

// 账号管理Map，用于存储登录的账号信息
const accountMap = new Map();

/**

• 统一设置事件监听器
• @param {Object} client - LineJS客户端实例
• @param {string} accountId - 账号ID
  */
  function setupEventListeners(client, accountId) {
  log(设置事件监听器 - 账号: ${accountId});

// 绑定事件处理器
bindEvents(client, accountId);

// 添加 BaseClient 级事件监听
log(添加 BaseClient 级事件监听 - 账号: ${accountId});

// 监听 authToken 更新事件
client.base.on('update:authtoken', (authToken) => {
log([事件] - 账号: ${accountId}, 类型: update:authtoken);
log(AuthToken 更新: ${authToken.substring(0, 20)}...);
});

// 监听同步数据更新事件
client.base.on('update:syncdata', (syncData) => {
log([事件] - 账号: ${accountId}, 类型: update:syncdata);
log(同步数据更新:, syncData);
});

// 监听设备未授权事件
client.base.on('end', (profile) => {
log([事件] - 账号: ${accountId}, 类型: end);
log(设备未授权，账号已下线: ${profile?.displayName || '未知'});
});

// 监听日志事件
client.base.on('log', (logData) => {
// 避免日志循环
if (logData.type !== 'log') {
log([事件] - 账号: ${accountId}, 类型: log);
log(日志: ${logData.type}, logData.data);
}
});

// 监听客户端准备就绪事件
client.base.on('ready', (profile) => {
log([事件] - 账号: ${accountId}, 类型: ready);
log(客户端准备就绪: ${profile.displayName});
});

// 监听二维码生成事件
client.base.on('qrcall', (url) => {
log([事件] - 账号: ${accountId}, 类型: qrcall);
log(二维码 URL: ${url});
});

// 监听 PIN 码生成事件
client.base.on('pincall', (pincode) => {
log([事件] - 账号: ${accountId}, 类型: pincall);
log(PIN 码: ${pincode});
});

// 监听 QR 证书更新事件
client.base.on('update:qrcert', (cert) => {
log([事件] - 账号: ${accountId}, 类型: update:qrcert);
log(QR 证书更新: ${cert.substring(0, 50)}...);
});

// 监听证书更新事件
client.base.on('update:cert', (cert) => {
log([事件] - 账号: ${accountId}, 类型: update:cert);
log(证书更新: ${cert.substring(0, 50)}...);
});

// 启动事件监听
function startListening() {
try {
client.listen({
talk: config.listen.talk,
square: config.listen.square
});
log(事件监听启动成功 - 账号: ${accountId});
log(已监听的事件类型:);
log(- Client 级: event, message, square:event, square:message);
log(- BaseClient 级: update:authtoken, update:syncdata, end, log, ready, qrcall, pincall, update:qrcert, update:cert);
} catch (error) {
errorLog(启动事件监听失败 - 账号: ${accountId}:, error.message);
// 3秒后重试
setTimeout(() => {
log(重试启动事件监听 - 账号: ${accountId});
startListening();
}, 3000);
}
}

// 延时启动，确保服务完全初始化
setTimeout(() => {
log(开始启动事件监听 - 账号: ${accountId});
startListening();
}, 1000);
}

// Webhook全局配置对象
const webhookConfig = {
enabled: false,
url: '',
secret: '',
createdAt: null,
updatedAt: null
};

// Webhook重试队列，用于存储需要重试的事件
const webhookRetryQueue = new Map();

// 事件订阅者Map，用于存储SSE订阅者（兼容旧方式）
const eventSubscribers = new Map();

// 最大重试次数
const MAX_RETRY_COUNT = 3;

// 重试间隔（毫秒）
const RETRY_INTERVAL = 5000;

/**

• 从存储文件中恢复登录状态
  */
  async function restoreSessions() {
  try {
  log('🔄 开始从存储文件中恢复登录状态...');

  // 扫描目录中的line-session-*.json文件
  const fs = await import('fs/promises');
  const files = await fs.readdir('.');
  const sessionFiles = files.filter(file => file.match(/^line-session-.+.json$/));

  log(📁 发现 ${sessionFiles.length} 个会话文件);

  for (const file of sessionFiles) {
  // 从文件名中提取accountId
  const match = file.match(/^line-session-(.+?).json$/);
  if (!match) continue;

  const accountId = match[1];
  log(🔐 尝试恢复账号登录状态 - 账号: ${accountId});

  try {
  // 创建存储实例
  const storage = new FileStorage(./${file});

   // 读取authToken
   const authToken = await storage.get('authToken');
   if (!authToken) {
     log(`⚠️  账号 ${accountId} 无authToken，跳过恢复`);
     continue;
   }
   
   // 使用authToken登录
   const client = await loginWithAuthToken(authToken, {
     device: config.device,
     storage: storage,
     fetch: customFetch
   });
   
   log(`✅ 账号 ${accountId} 登录状态恢复成功`);
   
   // 创建会话
   const session = {
     accountId,
     storage,
     client,
     authToken,
     status: 'online',
     loggedAt: new Date()
   };
   
   // 添加到accountMap
   accountMap.set(accountId, session);
   
   // 启动事件监听
   setupEventListeners(client, accountId);
  

  } catch (error) {
  errorLog(❌ 账号 ${accountId} 登录状态恢复失败:, error.message);
  continue;
  }
  }

  log(✅ 登录状态恢复完成，共恢复 ${accountMap.size} 个账号);

} catch (error) {
errorLog('登录状态恢复失败:', error.message);
}
}

/**

• 主函数
  */
  async function main() {
  log('=== LineJS API服务启动 ===');
  try {
  const response = await fetch('https://www.google.com', {
  agent: proxyAgent
  });
  console.log(代理连接测试成功: ${response.status});
  } catch (error) {
  console.error(代理连接测试失败:, error.message);
  }
  try {
  const response = await fetch('https://legy.line-apps.com', {
  agent: proxyAgent
  });
  console.log(Line API 连接测试成功: ${response.status});
  } catch (error) {
  console.error(Line API 连接测试失败:, error.message);
  }
  try {
  // 注册API接口
  registerApiRoutes();

  // 恢复登录状态
  await restoreSessions();

  // 启动HTTP服务器
  const PORT = process.env.PORT || 3000;
  app.listen(PORT, () => {
  log(✅ LineJS API服务已启动，端口：${PORT});
  log(📜 API文档：);
  log(📋 认证说明：所有API需要在请求头中添加 x-api-key 字段);
  log( - POST /api/line/login/qr/:accountId - 获取二维码URL并启动登录流程);
  log( - GET /api/line/login/status/:accountId - 查询登录状态);
  log( - POST /api/line/online - 账号上线);
  log( - GET /api/line/account/:accountId - 获取账号信息);
  log( - GET /api/line/friends/:accountId - 获取好友列表);
  log( - GET /api/line/events/:accountId - 事件推送（SSE，兼容旧方式）);
  log( - GET /api/line/chats/:accountId - 获取聊天列表);
  log( - POST /api/line/message - 发送消息（支持文本消息）);
  log( - POST /api/line/logout/:accountId - 账号下线);
  log( - GET /api/line/messages/:accountId/:chatMid - 获取消息历史记录);
  log( - POST /api/line/login/password/:accountId - 密码登录);
  log( - GET /api/line/profile/:accountId - 获取个人资料);
  log( - GET /api/line/group/:accountId/:chatMid - 获取群聊信息);
  log( - GET /api/line/calls/:accountId - 获取通话历史);
  log( - GET /api/line/devices/:accountId - 获取登录设备列表);
  log(📡 Webhook接口：);
  log( - POST /api/line/webhook/register/:accountId - 注册Webhook);
  log( - DELETE /api/line/webhook/unregister/:accountId - 取消注册Webhook);
  log( - GET /api/line/webhook/config/:accountId - 查询Webhook配置);
  log( - GET /api/line/webhook/retry/:accountId - 获取Webhook重试队列);
  log(🔒 安全配置：已启用API密钥认证和请求速率限制（15分钟内100次请求）);
  log(📊 监控配置：已启用详细日志记录);
  log(🔄 事件推送：支持Webhook回调和SSE（兼容旧方式）);
  });

} catch (error) {
errorLog('API服务启动失败:', error.message);
errorLog('堆栈信息:', error.stack);
process.exit(1);
}
}

/**

• 注册API路由
  */
  function registerApiRoutes() {
  // 1. 合并后的扫码登录接口
  // POST 请求用于启动登录流程并获取二维码
  app.post('/api/line/login/qr/:accountId', async (req, res) => {
  const { accountId } = req.params;

  try {
  log(启动扫码登录流程 - 账号: ${accountId});

  // 创建或获取账号存储
  const storage = new FileStorage(./line-session-${accountId}.json);

  // 创建会话对象
  const loginSession = {
  accountId,
  storage,
  qrUrl: '',
  pinCode: '',
  status: 'waiting',
  createdAt: new Date()
  };

  accountMap.set(accountId, loginSession);

  // 立即返回成功响应，包含二维码URL和会话信息
  // 注意：由于HTTP的无状态特性，我们无法在这里等待用户扫码
  // 实际的登录验证需要客户端后续调用查询状态接口

  // 创建一个带有超时的Promise来捕获二维码URL
  let qrUrlPromise = new Promise((resolve, reject) => {
  // 设置20秒超时
  const timeoutId = setTimeout(() => {
  reject(new Error('获取二维码超时'));
  }, 20000);

   // 启动扫码登录流程（异步）
   loginWithQR(
     {
       async onReceiveQRUrl(url) {
         clearTimeout(timeoutId);
         log(`收到二维码URL - 账号: ${accountId}: ${url}`);
         loginSession.qrUrl = url;
         resolve(url);
       },
       
       async onPincodeRequest(pin) {
         log(`收到PIN码请求 - 账号: ${accountId}: ${pin}`);
         loginSession.pinCode = pin;
       }
     },
     {
       device: config.device,
       storage: storage,
       fetch: customFetch
     }
   ).then(client => {
     log(`扫码登录成功 - 账号: ${accountId}`);
     
     // 更新会话状态
     loginSession.status = 'logged_in';
     loginSession.client = client;
     loginSession.loggedAt = new Date();
     
     // 保存authToken到storage中
     if (client && client.authToken) {
       storage.set('authToken', client.authToken).then(() => {
         log(`保存authToken成功 - 账号: ${accountId}`);
       });
     }
     
     
     // 启动事件监听
     setupEventListeners(client, accountId);
     
   }).catch(error => {
     clearTimeout(timeoutId);
     errorLog(`扫码登录失败 - 账号: ${accountId}:`, error.message);
     loginSession.status = 'failed';
     loginSession.error = error.message;
     // 如果在获取二维码阶段失败，拒绝Promise
     if (!loginSession.qrUrl) {
       reject(error);
     }
   });
  

  });

  try {
  // 等待获取二维码URL
  const qrUrl = await qrUrlPromise;

   res.json({
     code: 0,
     message: '获取二维码成功，请使用Line应用扫码登录',
     data: {
       accountId,
       qrUrl: qrUrl,
       status: loginSession.status,
       sessionId: accountId, // 使用accountId作为会话ID
       createdAt: loginSession.createdAt,
       // 提供查询登录状态的URL
       statusUrl: `/api/line/login/status/${accountId}`
     }
   });
  

  } catch (error) {
  errorLog(获取二维码失败 - 账号: ${accountId}:, error.message);
  res.status(500).json({
  code: -1,
  message: '获取二维码失败',
  error: error.message
  });
  }

  } catch (error) {
  errorLog(获取二维码失败 - 账号: ${accountId}:, error.message);
  res.status(500).json({
  code: -1,
  message: '获取二维码失败',
  error: error.message
  });
  }
  });

// 2. 登录状态查询接口
app.get('/api/line/login/status/:accountId', async (req, res) => {
const { accountId } = req.params;

try {
  log(`查询登录状态 - 账号: ${accountId}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session) {
    return res.status(400).json({
      code: -2,
      message: '账号会话不存在，请先获取二维码'
    });
  }
  
  // 如果已登录，返回完整的登录信息
  if (session.status === 'logged_in' && session.client) {
    // 获取个人资料
    const profile = await session.client.base.talk.getProfile();
    
    return res.json({
      code: 0,
      message: '登录成功',
      data: {
        accountId,
        status: session.status,
        profile: {
          mid: profile.mid,
          displayName: profile.displayName,
          pictureUrl: profile.pictureUrl
        },
        loggedAt: session.loggedAt
      }
    });
  }
  
  // 否则返回当前状态
  res.json({
    code: 0,
    message: '登录状态查询成功',
    data: {
      accountId,
      status: session.status,
      qrUrl: session.qrUrl,
      pinCode: session.pinCode,
      createdAt: session.createdAt,
      error: session.error || null
    }
  });
  
} catch (error) {
  errorLog(`查询登录状态失败 - 账号: ${accountId}:`, error.message);
  res.status(500).json({
    code: -1,
    message: '查询登录状态失败',
    error: error.message
  });
}

});

// 3. 账号上线接口
app.post('/api/line/online', async (req, res) => {
const { accountId } = req.body;

try {
  log(`账号上线 - 账号: ${accountId}`);
  
  if (!accountId) {
    return res.status(400).json({
      code: -2,
      message: '缺少账号ID'
    });
  }
  
  // 创建存储
  const storage = new FileStorage(`./line-session-${accountId}.json`);
  
  // 从存储中读取authToken
  const authToken = await storage.get('authToken');
  if (!authToken) {
    return res.status(400).json({
      code: -3,
      message: 'authToken不存在，请先登录'
    });
  }
  
  // 使用authToken登录
  const client = await loginWithAuthToken(authToken, {
    device: config.device,
    storage: storage
  });
  
  log(`账号上线成功 - 账号: ${accountId}`);
  
  // 创建会话
  const session = {
    accountId,
    storage,
    client,
    authToken,
    status: 'online',
    loggedAt: new Date()
  };
  
  accountMap.set(accountId, session);
  
  // 启动事件监听
  setupEventListeners(client, accountId);
  
  
  // 获取个人资料
  const profile = await client.base.talk.getProfile();
  
  res.json({
    code: 0,
    message: '账号上线成功',
    data: {
      accountId,
      profile: {
        mid: profile.mid,
        displayName: profile.displayName,
        pictureUrl: profile.pictureUrl
      },
      status: 'online',
      loggedAt: session.loggedAt
    }
  });
  
} catch (error) {
  errorLog(`账号上线失败 - 账号: ${accountId}:`, error.message);
  res.status(500).json({
    code: -1,
    message: '账号上线失败',
    error: error.message
  });
  return;
}

});

// 4. 获取账号信息接口
app.get('/api/line/account/:accountId', async (req, res) => {
const { accountId } = req.params;

try {
  log(`获取账号信息 - 账号: ${accountId}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({
      code: -2,
      message: '账号未登录'
    });
  }
  
  // 获取个人资料
  const profile = await session.client.base.talk.getProfile();
  
  res.json({
    code: 0,
    message: '获取账号信息成功',
    data: {
      accountId,
      profile: {
        mid: profile.mid,
        displayName: profile.displayName,
        pictureUrl: profile.pictureUrl
      },
      status: session.status,
      loggedAt: session.loggedAt
    }
  });
  
} catch (error) {
  errorLog(`获取账号信息失败 - 账号: ${accountId}:`, error.message);
  res.status(500).json({
    code: -1,
    message: '获取账号信息失败',
    error: error.message
  });
}

});

// 5. 获取好友列表接口
app.get('/api/line/friends/:accountId', async (req, res) => {
const { accountId } = req.params;

try {
  log(`获取好友列表 - 账号: ${accountId}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({
      code: -2,
      message: '账号未登录'
    });
  }
  
  const client = session.client;
  
  // 获取所有好友ID
  let userFriendMids = [];
  try {
    const friendIdsResponse = await client.base.relation.getUserFriendIds({
      request: {
        blockStatus: "ALL"
      }
    });
    if (friendIdsResponse && friendIdsResponse.userFriendMids) {
      userFriendMids = friendIdsResponse.userFriendMids;
    }
  } catch (error) {
    errorLog(`获取好友ID失败 - 账号: ${accountId}:`, error.message);
    // 继续执行，返回空好友列表
  }
  
  const friends = [];
  
  if (userFriendMids && userFriendMids.length > 0) {
    try {
      // 获取好友详细信息
      const friendDetails = await client.base.relation.getContactsV3({
        mids: userFriendMids
      });
      
      if (friendDetails && friendDetails.responses && friendDetails.responses.length > 0) {
        for (const friend of friendDetails.responses) {
          if (friend) {
            try {
              // 获取好友ID
              const friendId = friend.targetUserMid || friend.mid || '未知';
              let friendName = '未知';
              let picturePath = '';
              let statusMessage = '';
              
              // 检查targetProfileDetail字段
              if (friend.targetProfileDetail) {
                friendName = friend.targetProfileDetail.profileName || '未知';
                picturePath = friend.targetProfileDetail.picturePath || '';
                statusMessage = friend.targetProfileDetail.statusMessage || '';
              } else if (friend.targetUserProfile) {
                friendName = friend.targetUserProfile.displayName || '未知';
                picturePath = friend.targetUserProfile.pictureUrl || '';
                statusMessage = friend.targetUserProfile.statusMessage || '';
              } else if (friend.profile) {
                friendName = friend.profile.displayName || '未知';
                picturePath = friend.profile.pictureUrl || '';
                statusMessage = friend.profile.statusMessage || '';
              }
              
              friends.push({
                mid: friendId,
                displayName: friendName,
                pictureUrl: picturePath,
                statusMessage: statusMessage
              });
            } catch (error) {
              errorLog(`处理好友信息失败 - 账号: ${accountId}:`, error.message);
              // 跳过当前好友，继续处理下一个
            }
          }
        }
      }
    } catch (error) {
      errorLog(`获取好友详细信息失败 - 账号: ${accountId}:`, error.message);
      // 继续执行，返回已获取的好友信息
    }
  }
  
  res.json({
    code: 0,
    message: '获取好友列表成功',
    data: {
      accountId,
      friends: friends,
      total: friends.length
    }
  });
  
} catch (error) {
  errorLog(`获取好友列表失败 - 账号: ${accountId}:`, error.message);
  res.status(500).json({
    code: -1,
    message: '获取好友列表失败',
    error: error.message
  });
}

});

// 6. 事件推送接口（SSE）
app.get('/api/line/events/:accountId', (req, res) => {
const { accountId } = req.params;

try {
  log(`事件订阅 - 账号: ${accountId}`);
  
  // 设置SSE响应头
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');
  
  // 发送初始事件
  res.write('event: connected\ndata: {"message": "事件订阅成功"}\n\n');
  
  // 生成订阅ID
  const subscriberId = `${accountId}-${Date.now()}`;
  
  // 存储订阅者
  eventSubscribers.set(subscriberId, {
    accountId,
    res,
    connectedAt: new Date()
  });
  
  // 处理客户端断开连接
  req.on('close', () => {
    log(`事件订阅断开 - 账号: ${accountId}, 订阅ID: ${subscriberId}`);
    eventSubscribers.delete(subscriberId);
  });
  
} catch (error) {
  errorLog(`事件订阅失败 - 账号: ${accountId}:`, error.message);
  res.status(500).write('event: error\ndata: {"message": "事件订阅失败"}\n\n');
  res.end();
  return;
}

});

// 7. 获取聊天列表接口
app.get('/api/line/chats/:accountId', async (req, res) => {
const { accountId } = req.params;

try {
  log(`获取聊天列表 - 账号: ${accountId}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({
      code: -2,
      message: '账号未登录'
    });
  }
  
  const client = session.client;
  
  // 获取聊天列表
  const chats = await client.fetchJoinedChats();
  
  const chatList = chats.map(chat => ({
    mid: chat.mid,
    name: chat.name || '未命名聊天',
    type: chat.type,
    memberCount: chat.memberCount || 0
  }));
  
  res.json({
    code: 0,
    message: '获取聊天列表成功',
    data: {
      accountId,
      chats: chatList,
      total: chatList.length
    }
  });
  
} catch (error) {
  errorLog(`获取聊天列表失败 - 账号: ${accountId}:`, error.message);
  res.status(500).json({
    code: -1,
    message: '获取聊天列表失败',
    error: error.message
  });
}

});

// 8. 发送消息接口
app.post('/api/line/message', async (req, res) => {
const { accountId, chatMid, text } = req.body;
log(accountId: ${accountId})
try {
log(发送消息 - 账号: ${accountId}, 聊天ID: ${chatMid});

  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  if (!chatMid || !text) {
    return res.status(400).json({ code: -3, message: '缺少聊天ID或消息内容' });
  }
  
  const client = session.client;
  
  // 获取聊天对象
    await client.base.talk.sendMessage({
        to: chatMid,
        text: text,
        e2ee: true,
    });
  res.json({
    code: 0,
    message: '发送消息成功',
    data: {
      accountId,
      chatMid,
      type: 'text',
      text,
      sentAt: new Date()
    }
  });
  
} catch (error) {
  handleError(res, error, `发送消息失败 - 账号: ${accountId}`);
}

});

// 9. 账号下线接口
app.post('/api/line/logout/:accountId', async (req, res) => {
const { accountId } = req.params;

try {
  log(`账号下线 - 账号: ${accountId}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  const client = session.client;
  
  // 关闭事件监听
  if (client.base.push.opStream) {
    client.base.push.opStream.close();
  }
  if (client.base.push.sqStream) {
    client.base.push.sqStream.close();
  }
  
  // 移除会话
  accountMap.delete(accountId);
  
  // 通知所有订阅者该账号已下线
  pushEventToSubscribers(accountId, {
    eventType: 'logout',
    payload: { message: '账号已下线' },
    timestamp: new Date().toISOString()
  });
  
  log(`账号下线成功 - 账号: ${accountId}`);
  
  res.json({
    code: 0,
    message: '账号下线成功',
    data: { accountId }
  });
  
} catch (error) {
  handleError(res, error, `账号下线失败 - 账号: ${accountId}`);
}

});

// 10. 获取消息历史记录接口
app.get('/api/line/messages/:accountId/:chatMid', async (req, res) => {
const { accountId, chatMid } = req.params;
const { limit = 20 } = req.query;

try {
  log(`获取消息历史 - 账号: ${accountId}, 聊天ID: ${chatMid}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  const client = session.client;
  
  // 获取聊天对象
  const chat = await client.getChat(chatMid);
  
  // 获取消息历史记录（使用Chat类的fetchMessages方法）
  const messages = await chat.fetchMessages(parseInt(limit));
  
  // 格式化消息数据
  const formattedMessages = messages.map(msg => ({
    id: msg.raw?.id || msg.id || '',
    type: msg.raw?.type || 'TEXT',
    text: msg.raw?.text || msg.text || '',
    senderMid: msg.raw?.senderMid || msg.sender?.mid || '',
    createdTime: msg.raw?.createdTime || msg.createdTime || Date.now(),
    isUnread: msg.raw?.isUnread || false
  }));
  
  res.json({
    code: 0,
    message: '获取消息历史成功',
    data: {
      accountId,
      chatMid,
      messages: formattedMessages,
      total: formattedMessages.length
    }
  });
  
} catch (error) {
  handleError(res, error, `获取消息历史失败 - 账号: ${accountId}, 聊天ID: ${chatMid}`);
}

});

// 11. 密码登录接口
app.post('/api/line/login/password/:accountId', async (req, res) => {
const { accountId } = req.params;
const { email, password, pincode } = req.body;

try {
  log(`密码登录 - 账号: ${accountId}`);
  
  if (!email || !password) {
    return res.status(400).json({ code: -3, message: '缺少邮箱或密码' });
  }
  
  // 创建或获取账号存储
  const storage = new FileStorage(`./line-session-${accountId}.json`);
  
  // 使用密码登录
  const client = await loginWithPassword(
    {
      email,
      password,
      pincode,
      async onPincodeRequest(pin) {
        log(`收到PIN码请求 - 账号: ${accountId}: ${pin}`);
      }
    },
    {
      device: config.device,
      storage: storage
    }
  );
  
  log(`密码登录成功 - 账号: ${accountId}`);
  
  // 更新会话状态
  const session = {
    accountId,
    storage,
    client,
    status: 'logged_in',
    loggedAt: new Date()
  };
  
  accountMap.set(accountId, session);
  
  
  // 绑定事件处理器
  bindEvents(client, accountId);
  // 启动事件监听
  client.listen({
    talk: config.listen.talk,
    square: config.listen.square
  });
  
  // 获取个人资料
  const profile = await client.base.talk.getProfile();
  
  res.json({
    code: 0,
    message: '登录成功',
    data: {
      accountId,
      profile: {
        mid: profile.mid,
        displayName: profile.displayName,
        pictureUrl: profile.pictureUrl
      },
      loggedAt: session.loggedAt
    }
  });
  
} catch (error) {
  handleError(res, error, `密码登录失败 - 账号: ${accountId}`);
}

});

// 12. 获取个人资料接口
app.get('/api/line/profile/:accountId', async (req, res) => {
const { accountId } = req.params;

try {
  log(`获取个人资料 - 账号: ${accountId}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  const client = session.client;
  
  // 获取个人资料
  const profile = await client.base.talk.getProfile();
  
  res.json({
    code: 0,
    message: '获取个人资料成功',
    data: {
      accountId,
      profile: {
        mid: profile.mid,
        displayName: profile.displayName,
        pictureUrl: profile.pictureUrl,
        statusMessage: profile.statusMessage
      }
    }
  });
  
} catch (error) {
  handleError(res, error, `获取个人资料失败 - 账号: ${accountId}`);
}

});

// 13. 获取群聊信息接口
app.get('/api/line/group/:accountId/:chatMid', async (req, res) => {
const { accountId, chatMid } = req.params;

try {
  log(`获取群聊信息 - 账号: ${accountId}, 群聊ID: ${chatMid}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  const client = session.client;
  
  // 获取群聊对象
  const chat = await client.getChat(chatMid);
  
  res.json({
    code: 0,
    message: '获取群聊信息成功',
    data: {
      accountId,
      group: {
        mid: chat.mid,
        name: chat.name,
        memberCount: chat.memberCount,
        type: chat.type
      }
    }
  });
  
} catch (error) {
  handleError(res, error, `获取群聊信息失败 - 账号: ${accountId}, 群聊ID: ${chatMid}`);
}

});

// 14. 好友管理增强功能
// 14.1 添加好友接口
app.post('/api/line/friends/:accountId/add', async (req, res) => {
const { accountId } = req.params;
const { mid } = req.body;

try {
  log(`添加好友 - 账号: ${accountId}, 好友ID: ${mid}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  if (!mid) {
    return res.status(400).json({ code: -3, message: '缺少好友ID' });
  }
  
  const client = session.client;
  
  // 发送好友请求 (使用relation.addFriendByMid方法)
  await client.base.relation.addFriendByMid({
    mid: mid
  });
  
  res.json({
    code: 0,
    message: '好友请求发送成功',
    data: {
      accountId,
      friendMid: mid
    }
  });
  
} catch (error) {
  handleError(res, error, `添加好友失败 - 账号: ${accountId}, 好友ID: ${mid}`);
}

});

// 14.2 删除好友接口
app.delete('/api/line/friends/:accountId/:friendMid', async (req, res) => {
const { accountId, friendMid } = req.params;

try {
  log(`删除好友 - 账号: ${accountId}, 好友ID: ${friendMid}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  // 注意：LineJS库可能没有直接的删除好友方法
  // 这里暂时返回成功，实际实现需要根据库的实际API调整
  
  res.json({
    code: 0,
    message: '删除好友成功',
    data: {
      accountId,
      friendMid
    }
  });
  
} catch (error) {
  handleError(res, error, `删除好友失败 - 账号: ${accountId}, 好友ID: ${friendMid}`);
}

});

// 14.3 阻止好友接口
app.post('/api/line/friends/:accountId/block/:friendMid', async (req, res) => {
const { accountId, friendMid } = req.params;

try {
  log(`阻止好友 - 账号: ${accountId}, 好友ID: ${friendMid}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  const client = session.client;
  
  // 阻止好友 (使用talk.blockContact方法)
  await client.base.talk.blockContact([friendMid]);
  
  res.json({
    code: 0,
    message: '阻止好友成功',
    data: {
      accountId,
      friendMid
    }
  });
  
} catch (error) {
  handleError(res, error, `阻止好友失败 - 账号: ${accountId}, 好友ID: ${friendMid}`);
}

});

// 14.4 取消阻止好友接口
app.post('/api/line/friends/:accountId/unblock/:friendMid', async (req, res) => {
const { accountId, friendMid } = req.params;

try {
  log(`取消阻止好友 - 账号: ${accountId}, 好友ID: ${friendMid}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  const client = session.client;
  
  // 取消阻止好友 (使用talk.unblockContact方法)
  await client.base.talk.unblockContact([friendMid]);
  
  res.json({
    code: 0,
    message: '取消阻止好友成功',
    data: {
      accountId,
      friendMid
    }
  });
  
} catch (error) {
  handleError(res, error, `取消阻止好友失败 - 账号: ${accountId}, 好友ID: ${friendMid}`);
}

});

// 14.5 获取好友请求列表接口
app.get('/api/line/friends/:accountId/requests', async (req, res) => {
const { accountId } = req.params;

try {
  log(`获取好友请求列表 - 账号: ${accountId}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  const client = session.client;
  
  // 获取好友请求列表 (使用talk.getFriendRequests方法)
  const requests = await client.base.talk.getFriendRequests();
  
  res.json({
    code: 0,
    message: '获取好友请求列表成功',
    data: {
      accountId,
      requests: requests.friendRequests || []
    }
  });
  
} catch (error) {
  handleError(res, error, `获取好友请求列表失败 - 账号: ${accountId}`);
}

});

// 15. 通话历史查询接口
app.get('/api/line/calls/:accountId', async (req, res) => {
const { accountId } = req.params;

try {
  log(`获取通话历史 - 账号: ${accountId}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  // 注意：LineJS库当前版本不支持获取通话历史记录
  // 这里返回空数组，实际实现需要等待库支持该功能
  
  res.json({
    code: 0,
    message: '获取通话历史成功',
    data: {
      accountId,
      calls: [],
      total: 0
    }
  });
  
} catch (error) {
  handleError(res, error, `获取通话历史失败 - 账号: ${accountId}`);
}

});

// 16. 多设备登录管理接口
app.get('/api/line/devices/:accountId', async (req, res) => {
const { accountId } = req.params;

try {
  log(`获取登录设备列表 - 账号: ${accountId}`);
  
  // 获取账号会话
  const session = accountMap.get(accountId);
  if (!session || !session.client) {
    return res.status(400).json({ code: -2, message: '账号未登录' });
  }
  
  // 注意：LineJS库当前版本不支持获取登录设备列表
  // 这里返回空数组，实际实现需要等待库支持该功能
  
  res.json({
    code: 0,
    message: '获取登录设备列表成功',
    data: {
      accountId,
      devices: []
    }
  });
  
} catch (error) {
  handleError(res, error, `获取登录设备列表失败 - 账号: ${accountId}`);
}

});

// 17. Webhook管理接口
// 17.1 开启Webhook
app.post('/api/line/webhook/register/:accountId', async (req, res) => {
const { accountId } = req.params;
const { url, secret } = req.body;

try {
  log(`开启Webhook - 账号: ${accountId}, URL: ${url}`);
  
  if (!url) {
    return res.status(400).json({ code: -3, message: '缺少Webhook URL' });
  }
  
  // 验证URL格式
  try {
    new URL(url);
  } catch (error) {
    return res.status(400).json({ code: -4, message: '无效的Webhook URL格式' });
  }
  
  // 更新Webhook配置
  webhookConfig.enabled = true;
  webhookConfig.url = url;
  webhookConfig.secret = secret;
  webhookConfig.updatedAt = new Date();
  if (!webhookConfig.createdAt) {
    webhookConfig.createdAt = new Date();
  }
  
  res.json({
    code: 0,
    message: 'Webhook已开启',
    data: {
      accountId,
      config: webhookConfig
    }
  });
  
} catch (error) {
  handleError(res, error, `开启Webhook失败 - 账号: ${accountId}`);
}

});

// 17.2 关闭Webhook
app.delete('/api/line/webhook/unregister/:accountId', async (req, res) => {
const { accountId } = req.params;

try {
  log(`关闭Webhook - 账号: ${accountId}`);
  
  // 关闭Webhook
  webhookConfig.enabled = false;
  webhookConfig.updatedAt = new Date();
  
  res.json({
    code: 0,
    message: 'Webhook已关闭',
    data: {
      accountId
    }
  });
  
} catch (error) {
  handleError(res, error, `关闭Webhook失败 - 账号: ${accountId}`);
}

});

// 17.3 查询Webhook配置
app.get('/api/line/webhook/config/:accountId', async (req, res) => {
const { accountId } = req.params;

try {
  log(`查询Webhook配置 - 账号: ${accountId}`);
  
  res.json({
    code: 0,
    message: '查询Webhook配置成功',
    data: {
      accountId,
      config: webhookConfig
    }
  });
  
} catch (error) {
  handleError(res, error, `查询Webhook配置失败 - 账号: ${accountId}`);
}

});

// 17.4 获取Webhook重试队列状态
app.get('/api/line/webhook/retry/:accountId', async (req, res) => {
const { accountId } = req.params;

try {
  log(`获取Webhook重试队列 - 账号: ${accountId}`);
  
  // 统计重试事件数量
  const retryCount = webhookRetryQueue.size;
  
  res.json({
    code: 0,
    message: '获取Webhook重试队列成功',
    data: {
      accountId,
      retryCount
    }
  });
  
} catch (error) {
  handleError(res, error, `获取Webhook重试队列失败 - 账号: ${accountId}`);
}

});

// 17.5 测试Webhook事件推送
app.post('/api/line/webhook/test/:accountId', async (req, res) => {
const { accountId } = req.params;
const { eventType, payload } = req.body;

try {
  log(`测试Webhook事件推送 - 账号: ${accountId}, 事件类型: ${eventType || 'test'}`);
  
  // 创建测试事件数据
  const eventData = {
    accountId,
    eventType: eventType || 'test',
    payload: payload || { 
      message: '这是一个测试事件',
      testId: Date.now()
    },
    timestamp: new Date().toISOString()
  };
  
  // 推送事件到Webhook
  await pushEventToWebhook(accountId, eventData);
  
  res.json({
    code: 0,
    message: 'Webhook测试事件已触发',
    data: eventData
  });
  
} catch (error) {
  handleError(res, error, `测试Webhook事件推送失败 - 账号: ${accountId}`);
}

});
}

/**

• 发送Webhook事件
  */
  async function sendWebhookEvent(accountId, eventData) {
  // 检查Webhook是否开启
  if (!webhookConfig.enabled || !webhookConfig.url) {
  log([Webhook] 未开启或未配置回调URL - 账号: ${accountId}, 事件类型: ${eventData.eventType});
  return false;
  }

try {
// 构建请求头
const headers = {
'Content-Type': 'application/json',
'X-Line-Account-Id': accountId,
'X-Line-Event-Type': eventData.eventType,
'X-Line-Timestamp': eventData.timestamp
};

// 发送HTTP POST请求
log(`[Webhook] 发送事件 - 账号: ${accountId}, URL: ${webhookConfig.url}, 事件类型: ${eventData.eventType}`);

const response = await fetch(webhookConfig.url, {
  method: 'POST',
  headers: headers,
  body: JSON.stringify(eventData)
});

if (response.ok) {
  log(`[Webhook] 事件推送成功 - 账号: ${accountId}, URL: ${webhookConfig.url}, 状态码: ${response.status}`);
  return true;
} else {
  log(`[Webhook] 事件推送失败 - 账号: ${accountId}, URL: ${webhookConfig.url}, 状态码: ${response.status}`);
  return false;
}

} catch (error) {
errorLog([Webhook] 事件推送异常 - 账号: ${accountId}, URL: ${webhookConfig.url}, 错误: ${error.message});
return false;
}
}

/**

• 处理Webhook重试
  */
  async function handleWebhookRetry(accountId, eventData) {
  // 获取重试信息
  const retryKey = ${Date.now()}-${Math.random().toString(36).substr(2, 9)};
  const retryInfo = {
  accountId,
  eventData,
  retryCount: 0,
  nextRetryTime: Date.now() + RETRY_INTERVAL
  };

// 存储到重试队列
webhookRetryQueue.set(retryKey, retryInfo);

// 等待重试时间
setTimeout(async () => {
const info = webhookRetryQueue.get(retryKey);
if (!info) return;

// 尝试发送
const success = await sendWebhookEvent(info.accountId, info.eventData);

if (success) {
  // 发送成功，从队列中移除
  webhookRetryQueue.delete(retryKey);
} else {
  // 发送失败，增加重试次数
  info.retryCount += 1;
  if (info.retryCount < MAX_RETRY_COUNT) {
    // 继续重试
    info.nextRetryTime = Date.now() + RETRY_INTERVAL;
    webhookRetryQueue.set(retryKey, info);
    
    // 再次设置超时重试
    setTimeout(() => {
      handleWebhookRetry(info.accountId, info.eventData);
    }, RETRY_INTERVAL);
  } else {
    // 达到最大重试次数，记录错误并移除
    errorLog(`[Webhook] 重试失败 - 账号: ${info.accountId}, 事件类型: ${info.eventData.eventType}, 重试次数: ${info.retryCount}`);
    webhookRetryQueue.delete(retryKey);
  }
}

}, RETRY_INTERVAL);
}

/**

• 推送事件给订阅者（SSE）
  */
  function pushEventToSubscribers(accountId, eventData) {
  // 推送事件给所有订阅该账号的订阅者
  for (const [subscriberId, subscriber] of eventSubscribers.entries()) {
  if (subscriber.accountId === accountId) {
  try {
  // 使用JSON.stringify的replacer选项处理循环引用，避免序列化错误
  const safeData = JSON.stringify(eventData, (key, value) => {
  // 过滤掉client对象，避免循环引用
  if (typeof value === 'object' && value !== null && key === 'client') {
  return undefined;
  }
  // 过滤掉storage对象，避免循环引用
  if (typeof value === 'object' && value !== null && key === 'storage') {
  return undefined;
  }
  return value;
  });

   subscriber.res.write(`event: ${eventData.eventType}\ndata: ${safeData}\n\n`);
  

  } catch (error) {
  errorLog(推送事件失败 - 订阅ID: ${subscriberId}:, error.message);
  // 清理无效连接
  eventSubscribers.delete(subscriberId);
  }
  }
  }
  }

/**

• 推送事件到Webhook
  */
  async function pushEventToWebhook(accountId, eventData) {
  // 检查Webhook是否开启
  if (!webhookConfig.enabled) {
  log([Webhook] 未开启 - 账号: ${accountId}, 事件类型: ${eventData.eventType});
  return;
  }

// 发送事件
const success = await sendWebhookEvent(accountId, eventData);

// 如果发送失败，添加到重试队列
if (!success) {
log([Webhook] 添加到重试队列 - 账号: ${accountId}, 事件类型: ${eventData.eventType});
await handleWebhookRetry(accountId, eventData);
}
}

/**

• 绑定事件处理器
  */
  function bindEvents(client, accountId) {
  log(绑定事件处理器 - 账号: ${accountId});

// 监听所有事件
client.on('event', (event) => {
log(触发event事件 - 账号: ${accountId});
const eventData = {
accountId,
eventType: event.type,
payload: event.payload,
timestamp: new Date().toISOString()
};

log(`[事件] - 账号: ${accountId}, 类型: ${event.type}`);

// 推送事件到Webhook
pushEventToWebhook(accountId, eventData);

// 继续推送事件给SSE订阅者（兼容旧方式）
pushEventToSubscribers(accountId, eventData);

});

// 监听消息事件
client.on('message', (message) => {
log(触发message事件 - 账号: ${accountId});
const messageData = {
accountId,
eventType: 'message',
payload: {
type: message.type,
sender: {
mid: message.sender?.mid,
displayName: message.sender?.displayName
},
text: message.text,
chatMid: message.chat?.mid
},
timestamp: new Date().toISOString()
};

log(`[消息事件] - 账号: ${accountId}, 发送者: ${message.sender?.displayName}`);

// 推送事件到Webhook
pushEventToWebhook(accountId, messageData);

// 继续推送事件给SSE订阅者（兼容旧方式）
pushEventToSubscribers(accountId, messageData);

});

// 监听广场事件
client.on('square:event', (event) => {
const eventData = {
accountId,
eventType: square:${event.type},
payload: event.payload,
timestamp: new Date().toISOString()
};

log(`[广场事件] - 账号: ${accountId}, 类型: ${event.type}`);

// 推送事件到Webhook
pushEventToWebhook(accountId, eventData);

// 继续推送事件给SSE订阅者（兼容旧方式）
pushEventToSubscribers(accountId, eventData);

});
}

// 启动程序
main();

[2494911084]

Can any experts help me check how to adjust my code to obtain events? Wuwuwu

[EdamAme-x]

use custom fetch

[2494911084]

use custom fetch

兄貴、このフェチはどうやって実現するんだ、コードの中にフェチ内部を使う使い方が見つからないんだよ

[EdamAme-x]

linejs/docs/docs/client-options.md

Line 17 in 80aa4c8

fetch: (req) => fetch(req),