1091 lines
37 KiB
JavaScript
1091 lines
37 KiB
JavaScript
const express = require('express');
|
||
const http = require('http');
|
||
const path = require('path');
|
||
const os = require('os'); // Added for system stats
|
||
require('dotenv').config({ path: path.join(__dirname, '.env') });
|
||
require('dotenv').config({ path: path.join(__dirname, '..', '.env') });
|
||
const cors = require('cors');
|
||
const bodyParser = require('body-parser');
|
||
const { Server } = require('socket.io');
|
||
const { FarmBot } = require('./src/core/FarmBot');
|
||
const { loadProto, types } = require('./src/proto');
|
||
const { log, toLong, toNum } = require('./src/utils');
|
||
const { getLevelExpProgress, getPlantNameBySeedId, getFruitName, getItemNameById } = require('./src/gameConfig');
|
||
const userManager = require('./src/userManager');
|
||
const { MiniProgramLoginSession } = require('./src/qrlib/session');
|
||
|
||
// OAuth Dependencies
|
||
const session = require('express-session');
|
||
const passport = require('passport');
|
||
const OAuth2Strategy = require('passport-oauth2');
|
||
|
||
// 初始化 Express App
|
||
const app = express();
|
||
const server = http.createServer(app);
|
||
const io = new Server(server, {
|
||
cors: {
|
||
origin: "*", // 开发阶段允许跨域，生产环境应限制
|
||
methods: ["GET", "POST"]
|
||
}
|
||
});
|
||
|
||
const oauthEnabled = Boolean(process.env.OAUTH_AUTHENTIK_ISSUER)
|
||
&& Boolean(process.env.OAUTH_AUTHENTIK_CLIENT_ID)
|
||
&& Boolean(process.env.OAUTH_AUTHENTIK_CLIENT_SECRET)
|
||
&& Boolean(process.env.OAUTH_AUTHENTIK_REDIRECT_URI)
|
||
&& Boolean(process.env.OAUTH_AUTHENTIK_SCOPE);
|
||
|
||
// OAuth Setup
|
||
if (oauthEnabled) {
|
||
app.use(session({
|
||
secret: 'farm-session-secret',
|
||
resave: false,
|
||
saveUninitialized: false
|
||
}));
|
||
app.use(passport.initialize());
|
||
app.use(passport.session());
|
||
|
||
passport.serializeUser((user, done) => done(null, user.email));
|
||
passport.deserializeUser((email, done) => {
|
||
const user = userManager.getUser(email);
|
||
done(null, user);
|
||
});
|
||
|
||
passport.use('authentik', new OAuth2Strategy({
|
||
authorizationURL: `${process.env.OAUTH_AUTHENTIK_ISSUER}authorize/`,
|
||
tokenURL: `${process.env.OAUTH_AUTHENTIK_ISSUER}token/`,
|
||
clientID: process.env.OAUTH_AUTHENTIK_CLIENT_ID,
|
||
clientSecret: process.env.OAUTH_AUTHENTIK_CLIENT_SECRET,
|
||
callbackURL: process.env.OAUTH_AUTHENTIK_REDIRECT_URI,
|
||
scope: process.env.OAUTH_AUTHENTIK_SCOPE.split(' ')
|
||
}, async (accessToken, refreshToken, profile, cb) => {
|
||
try {
|
||
// Fetch user info using accessToken
|
||
const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
|
||
const userInfoRes = await fetch(`${process.env.OAUTH_AUTHENTIK_ISSUER}userinfo/`, {
|
||
headers: { 'Authorization': `Bearer ${accessToken}` }
|
||
});
|
||
const userInfo = await userInfoRes.json();
|
||
|
||
const email = userInfo.email || userInfo.preferred_username; // Adjust based on Authentik response
|
||
|
||
// Register or Login
|
||
const user = await userManager.register(email, null, 'authentik', userInfo.sub);
|
||
return cb(null, user);
|
||
} catch (err) {
|
||
return cb(err);
|
||
}
|
||
}));
|
||
|
||
// OAuth Routes
|
||
app.get('/api/auth/oauth/authentik', passport.authenticate('authentik', { state: true }));
|
||
|
||
app.get('/api/auth/oauth/authentik/callback', (req, res, next) => {
|
||
passport.authenticate('authentik', { state: true }, (err, user, info) => {
|
||
const frontendUrl = process.env.NODE_ENV === 'development' ? 'http://localhost:5173' : '';
|
||
|
||
if (err) {
|
||
console.error('OAuth Error:', err);
|
||
return res.redirect(`${frontendUrl}/login?error=oauth_failed`);
|
||
}
|
||
if (!user) {
|
||
console.error('OAuth Failed: No user returned');
|
||
return res.redirect(`${frontendUrl}/login?error=oauth_failed`);
|
||
}
|
||
|
||
req.logIn(user, (loginErr) => {
|
||
if (loginErr) {
|
||
console.error('Login Error:', loginErr);
|
||
return res.redirect(`${frontendUrl}/login?error=login_err`);
|
||
}
|
||
res.redirect(`${frontendUrl}/login?email=${encodeURIComponent(user.email)}&oauth=success&_t=${Date.now()}`);
|
||
});
|
||
})(req, res, next);
|
||
});
|
||
}
|
||
|
||
// 中间件
|
||
app.use(cors());
|
||
app.use(bodyParser.json());
|
||
if (process.env.NODE_ENV === 'production') {
|
||
app.use(express.static(path.join(__dirname, '../web/dist')));
|
||
}
|
||
|
||
app.get('/api/auth/oauth/status', (req, res) => {
|
||
res.json({ enabled: oauthEnabled });
|
||
});
|
||
|
||
// 存储活跃的 Bot 实例: Map<email, FarmBot>
|
||
const activeBots = new Map();
|
||
const unluckyBoards = new Map();
|
||
|
||
userManager.loadUnluckyBoards().then((stored) => {
|
||
if (!stored) return;
|
||
for (const [email, board] of stored.entries()) {
|
||
unluckyBoards.set(email, board);
|
||
}
|
||
}).catch((err) => {
|
||
log('Leaderboard', `加载失败: ${err.message}`);
|
||
});
|
||
|
||
|
||
function normalizeSettings(settings) {
|
||
if (!settings || typeof settings !== 'object') return {};
|
||
const result = {};
|
||
const farmIntervalSec = Number(settings.farmIntervalSec);
|
||
if (Number.isFinite(farmIntervalSec) && farmIntervalSec >= 1) {
|
||
result.farmCheckInterval = Math.floor(farmIntervalSec * 1000);
|
||
}
|
||
const friendIntervalSec = Number(settings.friendIntervalSec);
|
||
if (Number.isFinite(friendIntervalSec) && friendIntervalSec >= 1) {
|
||
result.friendCheckInterval = Math.floor(friendIntervalSec * 1000);
|
||
}
|
||
if (settings.seedStrategy === 'forceLowest') {
|
||
result.forceLowestLevelCrop = true;
|
||
} else if (settings.seedStrategy === 'default') {
|
||
result.forceLowestLevelCrop = false;
|
||
}
|
||
if (typeof settings.enableFriendOps === 'boolean') {
|
||
result.enableFriendOps = settings.enableFriendOps;
|
||
}
|
||
if (typeof settings.enableSteal === 'boolean') {
|
||
result.enableSteal = settings.enableSteal;
|
||
}
|
||
if (typeof settings.enableNormalFertilize === 'boolean') {
|
||
result.enableNormalFertilize = settings.enableNormalFertilize;
|
||
}
|
||
if (typeof settings.enableOrganicFertilize === 'boolean') {
|
||
result.enableOrganicFertilize = settings.enableOrganicFertilize;
|
||
}
|
||
if (typeof settings.allowTicketFertilizerPurchase === 'boolean') {
|
||
result.allowTicketFertilizerPurchase = settings.allowTicketFertilizerPurchase;
|
||
}
|
||
if (typeof settings.enableAutoSell === 'boolean') {
|
||
result.enableAutoSell = settings.enableAutoSell;
|
||
}
|
||
if (typeof settings.allowBuySeeds === 'boolean') {
|
||
result.allowBuySeeds = settings.allowBuySeeds;
|
||
}
|
||
if (typeof settings.allowRemove === 'boolean') {
|
||
result.allowRemove = settings.allowRemove;
|
||
}
|
||
if (settings.idleStrategy === 'task') {
|
||
result.idleStrategy = 'task';
|
||
} else if (settings.idleStrategy === 'exp') {
|
||
result.idleStrategy = 'exp';
|
||
}
|
||
return result;
|
||
}
|
||
|
||
function getTodayKey() {
|
||
const now = new Date();
|
||
const y = now.getFullYear();
|
||
const m = `${now.getMonth() + 1}`.padStart(2, '0');
|
||
const d = `${now.getDate()}`.padStart(2, '0');
|
||
return `${y}-${m}-${d}`;
|
||
}
|
||
|
||
async function fetchTaskInfo(bot) {
|
||
const body = types.TaskInfoRequest.encode(types.TaskInfoRequest.create({})).finish();
|
||
const { body: replyBody } = await bot.network.sendMsgAsync('gamepb.taskpb.TaskService', 'TaskInfo', body);
|
||
const reply = types.TaskInfoReply.decode(replyBody);
|
||
return reply.task_info || null;
|
||
}
|
||
|
||
function buildTaskList(taskInfo) {
|
||
const tasks = [];
|
||
if (!taskInfo) return tasks;
|
||
const seen = new Set();
|
||
const seenContent = new Set();
|
||
|
||
const addTasks = (list, category) => {
|
||
if (!list) return;
|
||
for (const task of list) {
|
||
const id = toNum(task.id);
|
||
if (seen.has(id)) continue;
|
||
const progress = toNum(task.progress);
|
||
const totalProgress = toNum(task.total_progress);
|
||
const isClaimed = Boolean(task.is_claimed);
|
||
const isUnlocked = Boolean(task.is_unlocked);
|
||
const shareMultiple = toNum(task.share_multiple);
|
||
const rewards = [];
|
||
const rewardList = task.rewards || [];
|
||
for (const reward of rewardList) {
|
||
rewards.push({
|
||
id: toNum(reward.id),
|
||
count: toNum(reward.count)
|
||
});
|
||
}
|
||
const desc = task.desc || `任务#${id}`;
|
||
const contentKey = `${desc.trim()}|${progress}|${totalProgress}`;
|
||
if (seenContent.has(contentKey)) continue;
|
||
tasks.push({
|
||
id,
|
||
desc,
|
||
progress,
|
||
totalProgress,
|
||
isClaimed,
|
||
isUnlocked,
|
||
shareMultiple,
|
||
rewards,
|
||
category
|
||
});
|
||
seen.add(id);
|
||
seenContent.add(contentKey);
|
||
}
|
||
};
|
||
|
||
addTasks(taskInfo.growth_tasks, 'growth');
|
||
addTasks(taskInfo.daily_tasks, 'daily');
|
||
addTasks(taskInfo.tasks, 'normal');
|
||
return tasks;
|
||
}
|
||
|
||
function isTaskClaimable(task) {
|
||
if (!task.isUnlocked || task.isClaimed) return false;
|
||
if (task.totalProgress <= 0) return false;
|
||
return task.progress >= task.totalProgress;
|
||
}
|
||
|
||
async function claimTaskReward(bot, taskId, doShared) {
|
||
const body = types.ClaimTaskRewardRequest.encode(types.ClaimTaskRewardRequest.create({
|
||
id: toLong(taskId),
|
||
do_shared: Boolean(doShared)
|
||
})).finish();
|
||
const { body: replyBody } = await bot.network.sendMsgAsync('gamepb.taskpb.TaskService', 'ClaimTaskReward', body);
|
||
return types.ClaimTaskRewardReply.decode(replyBody);
|
||
}
|
||
|
||
function updateUnluckyBoard(email, name, count) {
|
||
if (!email || !name || !Number.isFinite(count) || count <= 0) return;
|
||
let board = unluckyBoards.get(email);
|
||
if (!board) {
|
||
board = new Map();
|
||
unluckyBoards.set(email, board);
|
||
}
|
||
const prev = board.get(name) || 0;
|
||
board.set(name, prev + count);
|
||
userManager.saveUnlucky(email, name, count).catch((err) => {
|
||
log('Leaderboard', `保存失败: ${err.message}`);
|
||
});
|
||
}
|
||
|
||
// 初始化 Proto
|
||
loadProto().then(() => {
|
||
log('系统', '协议定义加载完成。');
|
||
}).catch(err => {
|
||
console.error('Failed to load Proto:', err);
|
||
process.exit(1);
|
||
});
|
||
|
||
// ============ API 路由 ============
|
||
|
||
// QR Code Login API (Mini Program)
|
||
app.post('/api/qr/create', async (req, res) => {
|
||
try {
|
||
log('扫码', '正在获取登录二维码...');
|
||
const result = await MiniProgramLoginSession.requestLoginCode();
|
||
log('扫码', '已获取登录二维码');
|
||
res.json({
|
||
success: true,
|
||
qrsig: result.code,
|
||
qrcode: `https://api.qrserver.com/v1/create-qr-code/?size=300x300&data=${encodeURIComponent(result.url)}`,
|
||
url: result.url
|
||
});
|
||
} catch (error) {
|
||
console.error('QR Create Error:', error);
|
||
res.status(500).json({ success: false, message: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/qr/check', async (req, res) => {
|
||
const { qrsig } = req.body;
|
||
if (!qrsig) {
|
||
return res.status(400).json({ success: false, message: 'Missing qrsig/code' });
|
||
}
|
||
|
||
try {
|
||
const result = await MiniProgramLoginSession.queryStatus(qrsig);
|
||
|
||
if (result.status === 'Wait') {
|
||
res.json({ success: true, status: 'Wait', msg: '等待扫码...' });
|
||
} else if (result.status === 'Used') {
|
||
res.json({ success: true, status: 'Used', msg: '二维码已失效' });
|
||
} else if (result.status === 'OK') {
|
||
const ticket = result.ticket;
|
||
// Determine AppID (Farm AppID)
|
||
const appid = MiniProgramLoginSession.Presets.farm.appid; // QQ Classic Farm
|
||
const code = await MiniProgramLoginSession.getAuthCode(ticket, appid);
|
||
|
||
res.json({
|
||
success: true,
|
||
status: 'OK',
|
||
msg: '登录成功',
|
||
code: code // This is the Game Code we need
|
||
});
|
||
} else {
|
||
res.json({ success: true, status: 'Error', msg: '状态查询错误' });
|
||
}
|
||
} catch (error) {
|
||
res.status(500).json({ success: false, message: error.message });
|
||
}
|
||
});
|
||
|
||
// 注册 API
|
||
app.post('/api/auth/register', async (req, res) => {
|
||
const { email, password } = req.body;
|
||
if (!email || !password) {
|
||
return res.status(400).json({ error: '请输入邮箱和密码' });
|
||
}
|
||
|
||
try {
|
||
if (userManager.getUser(email)) {
|
||
return res.status(400).json({ error: '该邮箱已被注册' });
|
||
}
|
||
|
||
const user = userManager.register(email, password);
|
||
log('Auth', `New user registered: ${email}`);
|
||
|
||
res.json({
|
||
success: true,
|
||
user: {
|
||
email: user.email,
|
||
hasCode: !!user.code
|
||
}
|
||
});
|
||
} catch (e) {
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
// 登录 API (仅登录)
|
||
app.post('/api/auth/login', async (req, res) => {
|
||
const { email, password } = req.body;
|
||
if (!email || !password) {
|
||
return res.status(400).json({ error: '请输入邮箱和密码' });
|
||
}
|
||
|
||
try {
|
||
const user = userManager.login(email, password);
|
||
if (!user) {
|
||
return res.status(401).json({ error: '邮箱或密码错误' });
|
||
}
|
||
|
||
// 返回用户信息和 Bot 状态
|
||
const botRunning = activeBots.has(email);
|
||
res.json({
|
||
success: true,
|
||
user: {
|
||
email: user.email,
|
||
code: user.code,
|
||
hasCode: !!user.code
|
||
},
|
||
botRunning
|
||
});
|
||
} catch (e) {
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
app.get('/api/auth/profile', async (req, res) => {
|
||
const { email } = req.query;
|
||
if (!email) {
|
||
return res.status(400).json({ error: 'Email is required' });
|
||
}
|
||
const user = userManager.getUser(email);
|
||
if (!user) {
|
||
return res.status(404).json({ error: 'User not found' });
|
||
}
|
||
res.json({
|
||
user: {
|
||
email: user.email,
|
||
hasCode: !!user.code,
|
||
auth_provider: user.auth_provider || 'local'
|
||
}
|
||
});
|
||
});
|
||
|
||
// 好友 API
|
||
app.get('/api/friends', async (req, res) => {
|
||
const { email } = req.query;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
|
||
const bot = activeBots.get(email);
|
||
if (bot.config && bot.config.enableFriendOps === false) {
|
||
return res.status(403).json({ error: 'Friend operations disabled' });
|
||
}
|
||
try {
|
||
const reply = await bot.friendManager.getAllFriends();
|
||
|
||
// 处理好友列表
|
||
const friends = (reply.friends || []).map(f => ({
|
||
uin: f.uin ? f.uin.toString() : '',
|
||
userName: f.userName,
|
||
headPic: f.headPic,
|
||
yellowLevel: f.yellowLevel,
|
||
exp: f.exp,
|
||
money: f.money
|
||
}));
|
||
|
||
res.json({ friends });
|
||
} catch (e) {
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
// 仓库出售 API
|
||
app.post('/api/warehouse/sell', async (req, res) => {
|
||
const { email, items } = req.body;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
|
||
if (!items || !Array.isArray(items) || items.length === 0) {
|
||
return res.status(400).json({ error: 'No items to sell' });
|
||
}
|
||
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
const reply = await bot.warehouseManager.sellItems(items);
|
||
const gold = bot.warehouseManager.extractGold(reply);
|
||
|
||
// 更新本地金币缓存
|
||
if (bot.user) {
|
||
bot.user.gold = (bot.user.gold || 0) + gold;
|
||
}
|
||
|
||
res.json({ success: true, gold });
|
||
} catch (e) {
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
// 访问好友农场 API
|
||
app.post('/api/friends/visit', async (req, res) => {
|
||
const { email, friendUid } = req.body;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
|
||
const bot = activeBots.get(email);
|
||
if (bot.config && bot.config.enableFriendOps === false) {
|
||
return res.status(403).json({ error: 'Friend operations disabled' });
|
||
}
|
||
try {
|
||
const reply = await bot.friendManager.enterFriendFarm(friendUid);
|
||
if (!reply.farm || !reply.farm.lands) {
|
||
return res.json({ lands: [] });
|
||
}
|
||
|
||
// 使用 FriendManager 的逻辑解析好友土地数据
|
||
const analysis = bot.friendManager.analyzeFriendLands(lands, bot.user.gid);
|
||
|
||
const formattedLands = lands.map(land => {
|
||
const id = Number(land.id);
|
||
if (!land.unlocked) return { id, type: 'locked' };
|
||
|
||
const plant = land.plant;
|
||
if (!plant || !plant.phases || plant.phases.length === 0) {
|
||
return { id, type: 'empty' };
|
||
}
|
||
|
||
const currentPhase = bot.farmManager.getCurrentPhase(plant.phases, false);
|
||
const phaseVal = currentPhase ? currentPhase.phase : 0;
|
||
|
||
// 6=Mature, 7=Dead
|
||
let status = 'growing';
|
||
if (phaseVal === 7) status = 'dead';
|
||
else if (phaseVal === 6) status = 'mature';
|
||
|
||
return {
|
||
id,
|
||
type: 'planted',
|
||
status,
|
||
plantId: Number(plant.id),
|
||
plantName: getPlantNameBySeedId(Number(plant.id)) || `作物${plant.id}`,
|
||
phase: phaseVal,
|
||
needs: {
|
||
water: analysis.needWater.includes(id),
|
||
weed: analysis.needWeed.includes(id),
|
||
bug: analysis.needBug.includes(id)
|
||
},
|
||
canSteal: analysis.stealable.includes(id) // 使用 analyzeFriendLands 的 stealable 结果
|
||
};
|
||
});
|
||
|
||
res.json({ lands: formattedLands, farmUser: reply.farm.user });
|
||
} catch (e) {
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
// 好友互动 API (偷菜/浇水等)
|
||
app.post('/api/friends/action', async (req, res) => {
|
||
const { email, friendUid, actionType, landIds } = req.body;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
|
||
const bot = activeBots.get(email);
|
||
if (bot.config && bot.config.enableFriendOps === false) {
|
||
return res.status(403).json({ error: 'Friend operations disabled' });
|
||
}
|
||
if (actionType === 'steal' && bot.config && bot.config.enableSteal === false) {
|
||
return res.status(403).json({ error: 'Steal disabled' });
|
||
}
|
||
try {
|
||
let result;
|
||
let message = '';
|
||
|
||
switch (actionType) {
|
||
case 'water':
|
||
result = await bot.friendManager.helpWater(friendUid, landIds);
|
||
message = '浇水成功';
|
||
break;
|
||
case 'weed':
|
||
result = await bot.friendManager.helpWeed(friendUid, landIds);
|
||
message = '除草成功';
|
||
break;
|
||
case 'insecticide':
|
||
result = await bot.friendManager.helpInsecticide(friendUid, landIds);
|
||
message = '除虫成功';
|
||
break;
|
||
case 'steal':
|
||
result = await bot.friendManager.stealHarvest(friendUid, landIds);
|
||
message = '偷菜成功';
|
||
break;
|
||
default:
|
||
throw new Error('Unknown action type');
|
||
}
|
||
|
||
res.json({ success: true, message, result });
|
||
} catch (e) {
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
// 启动 Bot API
|
||
app.post('/api/bot/start', async (req, res) => {
|
||
const { email, code, settings } = req.body; // 如果提供了 code，更新并启动
|
||
|
||
if (!email) {
|
||
return res.status(400).json({ error: 'Email is required' });
|
||
}
|
||
|
||
const user = userManager.getUser(email);
|
||
if (!user) {
|
||
return res.status(404).json({ error: 'User not found' });
|
||
}
|
||
|
||
// 如果提供了新 code，更新用户数据
|
||
let gameCode = code;
|
||
if (gameCode) {
|
||
userManager.updateCode(email, gameCode);
|
||
} else {
|
||
gameCode = user.code;
|
||
}
|
||
|
||
if (!gameCode) {
|
||
return res.status(400).json({ error: 'Game code is required. Please provide it.' });
|
||
}
|
||
|
||
try {
|
||
// 如果已存在 Bot，先停止
|
||
if (activeBots.has(email)) {
|
||
const oldBot = activeBots.get(email);
|
||
oldBot.stop();
|
||
activeBots.delete(email);
|
||
}
|
||
|
||
const botConfig = { code: gameCode, ...normalizeSettings(settings) };
|
||
const bot = new FarmBot(botConfig);
|
||
|
||
// 监听 Bot 事件并通过 Socket.IO 推送给前端 (使用 email 作为 room/key)
|
||
bot.on('started', () => {
|
||
io.emit(`bot-status-${email}`, { status: 'running' });
|
||
});
|
||
|
||
bot.on('stopped', () => {
|
||
io.emit(`bot-status-${email}`, { status: 'stopped' });
|
||
activeBots.delete(email);
|
||
});
|
||
|
||
bot.on('error', (err) => {
|
||
io.emit(`bot-error-${email}`, { message: err.message });
|
||
userManager.saveBotLog(email, { tag: 'Error', msg: err.message, type: 'error', time: Date.now() });
|
||
});
|
||
|
||
bot.on('log', (logData) => {
|
||
io.emit(`bot-log-${email}`, logData);
|
||
userManager.saveBotLog(email, logData);
|
||
});
|
||
bot.on('stealRecord', (data) => {
|
||
const name = data && data.name;
|
||
const count = Number(data && data.count);
|
||
updateUnluckyBoard(email, name, count);
|
||
});
|
||
|
||
// 启动 Bot
|
||
await bot.start();
|
||
activeBots.set(email, bot);
|
||
|
||
res.json({ success: true, message: 'Bot started successfully.' });
|
||
} catch (error) {
|
||
console.error('Bot start failed:', error);
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// 停止 Bot API
|
||
app.post('/api/bot/stop', (req, res) => {
|
||
const { email } = req.body;
|
||
if (activeBots.has(email)) {
|
||
const bot = activeBots.get(email);
|
||
bot.stop();
|
||
activeBots.delete(email);
|
||
res.json({ success: true });
|
||
} else {
|
||
res.status(404).json({ error: 'Bot is not running' });
|
||
}
|
||
});
|
||
|
||
// 获取状态 API
|
||
app.get('/api/status', async (req, res) => {
|
||
const { email } = req.query;
|
||
if (!email || !activeBots.has(email)) {
|
||
// 返回 stopped 状态而不是 404，以便前端正确显示 UI
|
||
return res.json({ status: 'stopped', user: null });
|
||
}
|
||
|
||
const bot = activeBots.get(email);
|
||
const user = bot.user || {};
|
||
const todayKey = getTodayKey();
|
||
const freeMallClaimed = user.freeMallClaimDate === todayKey;
|
||
|
||
// Calculate next level exp
|
||
const levelProgress = getLevelExpProgress(user.level || 0, user.exp || 0);
|
||
const tickets = user.tickets || 0;
|
||
const fertilizerContainer = Number(user.fertilizerContainer) || 0;
|
||
const fertilizerItems = user.fertilizerItems || {};
|
||
const fallbackHours = fertilizerContainer >= 3600 ? fertilizerContainer / 3600 : fertilizerContainer;
|
||
const organicFertilizerContainer = Number(user.organicFertilizerContainer) || 0;
|
||
const organicFertilizerItems = user.organicFertilizerItems || {};
|
||
const fallbackOrganicHours = organicFertilizerContainer >= 3600 ? organicFertilizerContainer / 3600 : organicFertilizerContainer;
|
||
let fertilizerHours = Number.isFinite(user.fertilizerHours) ? user.fertilizerHours : fallbackHours;
|
||
let organicFertilizerHours = Number.isFinite(user.organicFertilizerHours) ? user.organicFertilizerHours : fallbackOrganicHours;
|
||
if (bot.warehouseManager) {
|
||
try {
|
||
const bagReply = await bot.warehouseManager.getBag();
|
||
const items = bot.warehouseManager.getBagItems(bagReply);
|
||
let normalContainer = 0;
|
||
let organicContainer = 0;
|
||
for (const item of items) {
|
||
const id = toNum(item.id);
|
||
const count = toNum(item.count);
|
||
if (id === 1011) normalContainer = count;
|
||
if (id === 1012) organicContainer = count;
|
||
}
|
||
const normalContainerHours = normalContainer >= 3600 ? normalContainer / 3600 : normalContainer;
|
||
const organicContainerHours = organicContainer >= 3600 ? organicContainer / 3600 : organicContainer;
|
||
const normalHours = normalContainerHours;
|
||
const organicHours = organicContainerHours;
|
||
fertilizerHours = normalHours;
|
||
user.normalFertilizerHours = normalHours;
|
||
user.organicFertilizerHours = organicHours;
|
||
organicFertilizerHours = organicHours;
|
||
} catch (error) {
|
||
log('状态', `获取背包失败: ${error.message}`);
|
||
}
|
||
}
|
||
|
||
res.json({
|
||
status: 'running',
|
||
user: {
|
||
nickname: user.name || 'Farmer',
|
||
level: user.level || 0,
|
||
exp: levelProgress.current || 0,
|
||
nextLevelExp: levelProgress.needed || 100,
|
||
gold: user.gold || 0,
|
||
tickets,
|
||
fertilizerHours,
|
||
normalFertilizerHours: Number.isFinite(user.normalFertilizerHours) ? user.normalFertilizerHours : fertilizerHours,
|
||
organicFertilizerHours,
|
||
avatarUrl: user.avatarUrl || '',
|
||
freeMallClaimed
|
||
}
|
||
});
|
||
});
|
||
|
||
app.get('/api/announcement', (req, res) => {
|
||
const message = typeof process.env.LOGIN_ANNOUNCEMENT === 'string' ? process.env.LOGIN_ANNOUNCEMENT : '';
|
||
res.json({ message });
|
||
});
|
||
|
||
app.get('/api/logs', async (req, res) => {
|
||
const { email, limit } = req.query;
|
||
if (!email) {
|
||
return res.status(400).json({ error: 'Email is required' });
|
||
}
|
||
const count = Number(limit);
|
||
try {
|
||
const logs = await userManager.getBotLogs(email, count);
|
||
res.json({ logs });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.get('/api/debug/fertilizer', async (req, res) => {
|
||
const { email } = req.query;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
const bagReply = await bot.warehouseManager.getBag();
|
||
const items = bot.warehouseManager.getBagItems(bagReply);
|
||
let normalContainer = 0;
|
||
let normal1 = 0;
|
||
let normal4 = 0;
|
||
let normal8 = 0;
|
||
let normal12 = 0;
|
||
let organicContainer = 0;
|
||
let organic1 = 0;
|
||
let organic4 = 0;
|
||
let organic8 = 0;
|
||
let organic12 = 0;
|
||
for (const item of items) {
|
||
const id = toNum(item.id);
|
||
const count = toNum(item.count);
|
||
if (id === 1011) normalContainer = count;
|
||
if (id === 80001) normal1 = count;
|
||
if (id === 80002) normal4 = count;
|
||
if (id === 80003) normal8 = count;
|
||
if (id === 80004) normal12 = count;
|
||
if (id === 1012) organicContainer = count;
|
||
if (id === 80011) organic1 = count;
|
||
if (id === 80012) organic4 = count;
|
||
if (id === 80013) organic8 = count;
|
||
if (id === 80014) organic12 = count;
|
||
}
|
||
const normalContainerHours = normalContainer >= 3600 ? normalContainer / 3600 : normalContainer;
|
||
const organicContainerHours = organicContainer >= 3600 ? organicContainer / 3600 : organicContainer;
|
||
const normalHours = normalContainerHours + normal1 + normal4 * 4 + normal8 * 8 + normal12 * 12;
|
||
const organicHours = organicContainerHours + organic1 + organic4 * 4 + organic8 * 8 + organic12 * 12;
|
||
res.json({
|
||
normal: {
|
||
container: normalContainer,
|
||
hour1: normal1,
|
||
hour4: normal4,
|
||
hour8: normal8,
|
||
hour12: normal12,
|
||
hours: normalHours
|
||
},
|
||
organic: {
|
||
container: organicContainer,
|
||
hour1: organic1,
|
||
hour4: organic4,
|
||
hour8: organic8,
|
||
hour12: organic12,
|
||
hours: organicHours
|
||
}
|
||
});
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.get('/api/leaderboard/unlucky', (req, res) => {
|
||
const { email } = req.query;
|
||
if (!email) {
|
||
return res.status(400).json({ error: 'Email is required' });
|
||
}
|
||
if (activeBots.has(email)) {
|
||
const bot = activeBots.get(email);
|
||
if (bot.config && bot.config.enableFriendOps === false) {
|
||
return res.json({ items: [] });
|
||
}
|
||
if (bot.config && bot.config.enableSteal === false) {
|
||
return res.json({ items: [] });
|
||
}
|
||
}
|
||
const board = unluckyBoards.get(email);
|
||
if (!board) {
|
||
return res.json({ items: [] });
|
||
}
|
||
const items = Array.from(board.entries())
|
||
.map(([name, count]) => ({ name, count }))
|
||
.sort((a, b) => b.count - a.count)
|
||
.slice(0, 10);
|
||
res.json({ items });
|
||
});
|
||
|
||
app.get('/api/tasks', async (req, res) => {
|
||
const { email } = req.query;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
const taskInfo = await fetchTaskInfo(bot);
|
||
const tasks = buildTaskList(taskInfo);
|
||
res.json({ tasks });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/tasks/claim', async (req, res) => {
|
||
const { email } = req.body;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
const taskInfo = await fetchTaskInfo(bot);
|
||
const tasks = buildTaskList(taskInfo);
|
||
const claimable = [];
|
||
for (const task of tasks) {
|
||
if (isTaskClaimable(task)) {
|
||
claimable.push(task);
|
||
}
|
||
}
|
||
let claimedCount = 0;
|
||
const failed = [];
|
||
for (const task of claimable) {
|
||
try {
|
||
await claimTaskReward(bot, task.id, task.shareMultiple > 1);
|
||
claimedCount += 1;
|
||
} catch (err) {
|
||
failed.push({ id: task.id, message: err.message });
|
||
}
|
||
}
|
||
|
||
const latestTaskInfo = await fetchTaskInfo(bot);
|
||
const latestTasks = buildTaskList(latestTaskInfo);
|
||
res.json({ claimedCount, failed, tasks: latestTasks });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/tasks/claim-one', async (req, res) => {
|
||
const { email, taskId, doShared } = req.body;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
const id = Number(taskId);
|
||
if (!Number.isFinite(id) || id <= 0) {
|
||
return res.status(400).json({ error: 'Invalid taskId' });
|
||
}
|
||
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
await claimTaskReward(bot, id, Boolean(doShared));
|
||
const latestTaskInfo = await fetchTaskInfo(bot);
|
||
const latestTasks = buildTaskList(latestTaskInfo);
|
||
res.json({ claimedCount: 1, failedCount: 0, tasks: latestTasks });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Get lands API
|
||
app.get('/api/lands', async (req, res) => {
|
||
const { email } = req.query;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
const lands = await bot.farmManager.getFormattedLands();
|
||
res.json({ lands });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/lands/remove', async (req, res) => {
|
||
const { email, landIds } = req.body;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
if (!Array.isArray(landIds)) {
|
||
return res.status(400).json({ error: 'Invalid landIds' });
|
||
}
|
||
const ids = landIds.map(Number).filter(id => Number.isFinite(id) && id > 0);
|
||
if (ids.length === 0) {
|
||
return res.status(400).json({ error: 'Invalid landIds' });
|
||
}
|
||
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
await bot.farmManager.removePlant(ids);
|
||
res.json({ success: true, removed: ids.length });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/lands/unlock', async (req, res) => {
|
||
const { email, landId, doShared } = req.body;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
const id = Number(landId);
|
||
if (!Number.isFinite(id) || id <= 0) {
|
||
return res.status(400).json({ error: 'Invalid landId' });
|
||
}
|
||
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
await bot.farmManager.unlockLand(id, Boolean(doShared));
|
||
res.json({ success: true, landId: id });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Shop API
|
||
app.get('/api/shop', async (req, res) => {
|
||
const { email } = req.query;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
const goods = await bot.shopManager.getSeedShopList();
|
||
res.json({ goods });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/shop/buy', async (req, res) => {
|
||
const { email, goodsId, count, price } = req.body;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
await bot.shopManager.buyGoods(goodsId, count, price);
|
||
res.json({ success: true });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/paymall/buy', async (req, res) => {
|
||
const { email, itemId, count } = req.body;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
const id = Number(itemId);
|
||
if (!Number.isFinite(id) || id <= 0) {
|
||
return res.status(400).json({ error: 'Invalid itemId' });
|
||
}
|
||
const buyCount = Number(count ?? 1);
|
||
if (!Number.isFinite(buyCount) || buyCount <= 0) {
|
||
return res.status(400).json({ error: 'Invalid count' });
|
||
}
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
await bot.shopManager.purchaseMallItem(id, buyCount);
|
||
if (id === 1001) {
|
||
bot.user.freeMallClaimDate = getTodayKey();
|
||
bot.emit('userUpdate', bot.user);
|
||
}
|
||
res.json({ success: true });
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
// Warehouse API
|
||
app.get('/api/warehouse', async (req, res) => {
|
||
const { email } = req.query;
|
||
if (!email || !activeBots.has(email)) {
|
||
return res.status(404).json({ error: 'Bot not running' });
|
||
}
|
||
const bot = activeBots.get(email);
|
||
try {
|
||
const data = await bot.warehouseManager.getFormattedBag();
|
||
res.json(data);
|
||
} catch (error) {
|
||
res.status(500).json({ error: error.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/warehouse/sell', async (req, res) => {
|
||
const { email, items } = req.body;
|
||
const bot = activeBots.get(email);
|
||
if (!bot) return res.status(404).json({ error: 'Bot not found' });
|
||
|
||
try {
|
||
const reply = await bot.warehouseManager.sellItems(items);
|
||
const gold = bot.warehouseManager.extractGold(reply);
|
||
res.json({ success: true, gold });
|
||
} catch (e) {
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
app.post('/api/warehouse/use', async (req, res) => {
|
||
const { email, items } = req.body;
|
||
const bot = activeBots.get(email);
|
||
if (!bot) return res.status(404).json({ error: 'Bot not found' });
|
||
|
||
try {
|
||
const result = await bot.warehouseManager.useItems(items);
|
||
res.json(result);
|
||
} catch (e) {
|
||
res.status(500).json({ error: e.message });
|
||
}
|
||
});
|
||
|
||
// System stats API
|
||
app.get('/api/system/stats', (req, res) => {
|
||
const memory = process.memoryUsage();
|
||
// Convert to MB
|
||
const memoryUsage = {
|
||
rss: Math.round(memory.rss / 1024 / 1024),
|
||
heapTotal: Math.round(memory.heapTotal / 1024 / 1024),
|
||
heapUsed: Math.round(memory.heapUsed / 1024 / 1024),
|
||
};
|
||
|
||
res.json({
|
||
memory: memoryUsage,
|
||
uptime: Math.floor(process.uptime()),
|
||
activeBots: activeBots.size
|
||
});
|
||
});
|
||
|
||
// 所有其他请求返回前端 index.html (SPA 支持)
|
||
app.get('*', (req, res) => {
|
||
if (process.env.NODE_ENV === 'production') {
|
||
res.sendFile(path.join(__dirname, '../web/dist/index.html'));
|
||
} else {
|
||
res.status(404).send('Not Found (Development Mode: Use Frontend Dev Server at port 5173)');
|
||
}
|
||
});
|
||
|
||
// ============ Socket.IO ============
|
||
io.on('connection', (socket) => {
|
||
log('Server', `Client connected: ${socket.id}`);
|
||
|
||
socket.on('disconnect', () => {
|
||
log('Server', `Client disconnected: ${socket.id}`);
|
||
});
|
||
});
|
||
|
||
// 启动服务器
|
||
const PORT = process.env.PORT || 3000;
|
||
server.listen(PORT, () => {
|
||
log('Server', `Server running on http://localhost:${PORT}`);
|
||
});
|