Upload 50 files

.dockerignore

@@ -1,9 +1,10 @@
-node_modules
-.env
-.git
-.gitignore
-*.md
-LICENSE
-Dockerfile
-.dockerignore
-npm-debug.log
+node_modules
+.env
+.git
+.gitignore
+*.md
+LICENSE
+Dockerfile
+.dockerignore
+npm-debug.log
+gifs

api.js

@@ -6,92 +6,64 @@ const User = require('./models/User');
 const app = express();
 app.use(express.json());
 
-// ── CORS — MUST be before static files and routes ──
-const WEBAPP_ORIGIN = process.env.WEBAPP_ORIGIN || '*';
+// ── CORS ──
 app.use((req, res, next) => {
-    res.setHeader('Access-Control-Allow-Origin', WEBAPP_ORIGIN);
+    res.setHeader('Access-Control-Allow-Origin', process.env.WEBAPP_ORIGIN || '*');
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-Init-Data');
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
     if (req.method === 'OPTIONS') return res.sendStatus(204);
     next();
 });
 
-// ── Serve Static WebApp ──
+// ── Static files ──
 app.use(express.static(path.join(__dirname, 'webapp')));
-
-// ── Explicit routes for game pages (fallback if static doesn't catch) ──
 app.get('/carrom', (req, res) => res.sendFile(path.join(__dirname, 'webapp', 'carrom.html')));
 app.get('/cards', (req, res) => res.sendFile(path.join(__dirname, 'webapp', 'cards.html')));
 
-// ── Telegram initData verification ──
-function verifyInitData(initDataRaw) {
+// ── Request timeout — prevent hanging ──
+app.use((req, res, next) => {
+    res.setTimeout(10000, () => { // 10 second timeout
+        if (!res.headersSent) res.status(408).json({ ok: false, error: 'Request timeout' });
+    });
+    next();
+});
+
+// ── Auth ──
+function verifyInitData(raw) {
     try {
-        const params = new URLSearchParams(initDataRaw);
-        const hash = params.get('hash');
-        if (!hash) return null;
+        const params = new URLSearchParams(raw);
+        const hash = params.get('hash'); if (!hash) return null;
         params.delete('hash');
-        const checkString = [...params.entries()]
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([k, v]) => `${k}=${v}`)
-            .join('\n');
-        const secret = crypto
-            .createHmac('sha256', 'WebAppData')
-            .update(process.env.BOT_TOKEN)
-            .digest();
-        const expectedHash = crypto
-            .createHmac('sha256', secret)
-            .update(checkString)
-            .digest('hex');
-        if (expectedHash !== hash) return null;
-        const userStr = params.get('user');
-        return userStr ? JSON.parse(userStr) : null;
+        const cs = [...params.entries()].sort(([a],[b])=>a.localeCompare(b)).map(([k,v])=>`${k}=${v}`).join('\n');
+        const secret = crypto.createHmac('sha256','WebAppData').update(process.env.BOT_TOKEN).digest();
+        if (crypto.createHmac('sha256',secret).update(cs).digest('hex') !== hash) return null;
+        const u = params.get('user'); return u ? JSON.parse(u) : null;
     } catch { return null; }
 }
 
-// ── Auth middleware ──
 function auth(req, res, next) {
-    const initDataRaw = req.headers['x-init-data'] || req.query.initData;
-    if (!initDataRaw) {
-        console.log('[API] Auth fail: Missing initData on', req.method, req.path);
-        return res.status(401).json({ ok: false, error: 'Missing initData' });
-    }
-    const tgUser = verifyInitData(initDataRaw);
-    if (!tgUser) {
-        console.log('[API] Auth fail: Invalid signature on', req.method, req.path);
-        return res.status(403).json({ ok: false, error: 'Invalid initData' });
-    }
-    req.tgUser = tgUser;
-    next();
+    const raw = req.headers['x-init-data'] || req.query.initData;
+    if (!raw) return res.status(401).json({ ok: false, error: 'Missing auth' });
+    const user = verifyInitData(raw);
+    if (!user) return res.status(403).json({ ok: false, error: 'Invalid auth' });
+    req.tgUser = user; next();
 }
 
 // ── GET /status ──
 app.get('/status', auth, async (req, res) => {
     try {
-        const { type } = req.query;
         const userId = req.tgUser.id.toString();
         const user = await User.findOne({ userId });
-        const now = new Date();
-        const todayStr = now.toISOString().split('T')[0];
-
+        const today = new Date().toISOString().split('T')[0];
         if (!user) return res.json({ canClaim: true, hoursLeft: null, adsLeft: 50 });
-
-        if (type === 'mission_inpage') {
-            const lastAdDate = user.lastAdWatchDate ? user.lastAdWatchDate.toISOString().split('T')[0] : null;
-            let currentCount = user.dailyAdsCount || 0;
-            if (lastAdDate !== todayStr) currentCount = 0;
-            const adsLeft = Math.max(0, 50 - currentCount);
-            return res.json({ canClaim: adsLeft > 0, hoursLeft: adsLeft > 0 ? null : 24, adsLeft });
+        if (req.query.type === 'mission_inpage') {
+            const ld = user.lastAdWatchDate?.toISOString().split('T')[0];
+            let cnt = ld !== today ? 0 : (user.dailyAdsCount || 0);
+            return res.json({ canClaim: 50 - cnt > 0, adsLeft: Math.max(0, 50 - cnt) });
         }
-
-        const lastClaim = user.lastDaily;
-        if (!lastClaim) return res.json({ canClaim: true, hoursLeft: null });
-        const lastStr = lastClaim.toISOString().split('T')[0];
-        if (lastStr !== todayStr) return res.json({ canClaim: true, hoursLeft: null });
-        return res.json({ canClaim: false, hoursLeft: 24 });
-    } catch (err) {
-        console.error('[API] /status error:', err);
-        res.status(500).json({ error: 'Server error' });
-    }
+        const ld = user.lastDaily?.toISOString().split('T')[0];
+        res.json({ canClaim: ld !== today, hoursLeft: ld === today ? 24 : null });
+    } catch (err) { res.status(500).json({ error: 'Error' }); }
 });
 
 // ── POST /claim ──
@@ -99,62 +71,40 @@ app.post('/claim', auth, async (req, res) => {
     try {
         const { type } = req.body;
         const userId = req.tgUser.id.toString();
-        let user = await User.findOne({ userId });
-        if (!user) user = await User.create({ userId, username: req.tgUser.username });
-        const now = new Date();
-        const todayStr = now.toISOString().split('T')[0];
-
+        let user = await User.findOne({ userId }) || await User.create({ userId, username: req.tgUser.username });
+        const today = new Date().toISOString().split('T')[0];
         if (type === 'daily') {
-            const lastStr = user.lastDaily ? user.lastDaily.toISOString().split('T')[0] : null;
-            if (lastStr === todayStr) return res.json({ ok: false, error: 'Already claimed today' });
-            const reward = 3000, xpGain = 100;
-            user.wallet += reward; user.xp = (user.xp || 0) + xpGain; user.lastDaily = now;
-            await user.save();
-            console.log(`[API] daily reward: ${userId} +$${reward}`);
-            if (global._tgClient) {
-                try { await global._tgClient.sendMessage(userId, { message: `🎉 <b>Daily Reward Claimed!</b>\n\n💰 <b>+$${reward}</b>\n✨ <b>+${xpGain} XP</b>\n\nCome back tomorrow! 🌟` }); } catch (e) {}
-            }
-            return res.json({ ok: true, reward, xp: xpGain, wallet: user.wallet });
+            if (user.lastDaily?.toISOString().split('T')[0] === today) return res.json({ ok: false, error: 'Already claimed' });
+            user.wallet += 3000; user.xp += 100; user.lastDaily = new Date(); await user.save();
+            if (global._tgClient) try { await global._tgClient.sendMessage(userId, { message: `🎉 <b>+$3000</b> daily reward!` }); } catch {}
+            return res.json({ ok: true, reward: 3000, wallet: user.wallet });
         } else if (type === 'mission') {
-            const lastAdDate = user.lastAdWatchDate ? user.lastAdWatchDate.toISOString().split('T')[0] : null;
-            if (lastAdDate !== todayStr) user.dailyAdsCount = 0;
-            if (user.dailyAdsCount >= 50) return res.json({ ok: false, error: 'Daily limit reached (50)' });
-            const reward = 200;
-            user.wallet += reward; user.dailyAdsCount += 1;
-            user.lastAdWatchDate = now; user.lastInpageMissionClaim = now; user.lastMissionClaim = now;
+            const ld = user.lastAdWatchDate?.toISOString().split('T')[0];
+            if (ld !== today) user.dailyAdsCount = 0;
+            if (user.dailyAdsCount >= 50) return res.json({ ok: false, error: 'Limit reached' });
+            user.wallet += 200; user.dailyAdsCount++; user.lastAdWatchDate = new Date(); user.lastMissionClaim = new Date();
             await user.save();
-            const adsLeft = 50 - user.dailyAdsCount;
-            if (global._tgClient) {
-                try { await global._tgClient.sendMessage(userId, { message: `🎯 <b>Mission Complete!</b>\n\nYou've earned <b>$200</b>! (${adsLeft} left today) 🎖️` }); } catch (e) {}
-            }
-            return res.json({ ok: true, reward, adsLeft, wallet: user.wallet });
+            return res.json({ ok: true, reward: 200, adsLeft: 50 - user.dailyAdsCount, wallet: user.wallet });
         }
-        return res.status(400).json({ ok: false, error: 'Invalid type' });
-    } catch (err) {
-        console.error('[API] /claim error:', err);
-        res.status(500).json({ ok: false, error: 'Server error' });
-    }
+        res.status(400).json({ ok: false, error: 'Invalid type' });
+    } catch (err) { res.status(500).json({ ok: false, error: 'Error' }); }
 });
 
-// ── GET /leaderboard ──
+// ── GET /leaderboard — NO getEntity calls (was causing server hang) ──
 app.get('/leaderboard', auth, async (req, res) => {
     try {
         const { type = 'wallet', period = 'all' } = req.query;
-        const sortFields = { bank: { bank: -1 }, wallet: { wallet: -1 }, xp: { xp: -1 }, kills: { kills: -1 }, robs: { robs: -1 } };
-        const sort = sortFields[type] || { wallet: -1 };
-        let dateFilter = {};
+        const sorts = { bank:{bank:-1}, wallet:{wallet:-1}, xp:{xp:-1}, kills:{kills:-1}, robs:{robs:-1} };
+        let df = {};
         const now = new Date();
-        if (period === 'daily') dateFilter = { lastDaily: { $gte: new Date(now.toISOString().split('T')[0]) } };
-        else if (period === 'weekly') dateFilter = { lastDaily: { $gte: new Date(now.getTime() - 7 * 86400000) } };
-        else if (period === 'monthly') dateFilter = { lastDaily: { $gte: new Date(now.getTime() - 30 * 86400000) } };
-        const users = await User.find(dateFilter).sort(sort).limit(50).select('userId username wallet bank xp level kills robs totalEarned').lean();
-        if (global._tgClient) {
-            for (const u of users) {
-                if (!u.username) { try { const ent = await global._tgClient.getEntity(u.userId); u.username = ent.username || ent.firstName || `User${u.userId.slice(-4)}`; } catch { u.username = `User${u.userId.slice(-4)}`; } }
-            }
-        } else { for (const u of users) if (!u.username) u.username = `User${u.userId.slice(-4)}`; }
+        if (period === 'daily') df = { lastDaily: { $gte: new Date(now.toISOString().split('T')[0]) } };
+        else if (period === 'weekly') df = { lastDaily: { $gte: new Date(now - 7*86400000) } };
+        else if (period === 'monthly') df = { lastDaily: { $gte: new Date(now - 30*86400000) } };
+        const users = await User.find(df).sort(sorts[type]||{wallet:-1}).limit(50).select('userId username wallet bank xp level kills robs').lean();
+        // Just use stored username — NO getEntity calls
+        for (const u of users) if (!u.username) u.username = `User${u.userId.slice(-4)}`;
         res.json({ ok: true, leaderboard: users, type, period });
-    } catch (err) { console.error('[API] /leaderboard error:', err); res.status(500).json({ error: 'Server error' }); }
+    } catch (err) { res.status(500).json({ error: 'Error' }); }
 });
 
 // ── GET /me ──
@@ -162,234 +112,124 @@ app.get('/me', auth, async (req, res) => {
     try {
         const userId = req.tgUser.id.toString();
         let user = await User.findOne({ userId }).lean();
-        if (!user) { user = await User.create({ userId, username: req.tgUser.username }); user = user.toObject(); }
+        if (!user) { user = (await User.create({ userId, username: req.tgUser.username })).toObject(); }
         res.json({ ok: true, user });
-    } catch (err) { console.error('[API] /me error:', err); res.status(500).json({ error: 'Server error' }); }
+    } catch (err) { res.status(500).json({ error: 'Error' }); }
 });
 
-// ── POST /carrom/start — Host starts game from Mini App ──
+// ── Carrom API ──
 app.post('/carrom/start', auth, async (req, res) => {
     try {
         const { gameId } = req.body;
-        if (!gameId) return res.json({ ok: false, error: 'Missing gameId' });
         const sessions = require('./games/sessions');
         const game = sessions.get(gameId);
-        if (!game) return res.json({ ok: false, error: 'Game not found' });
-        if (game.status !== 'lobby') return res.json({ ok: false, error: 'Game already started' });
-        const userId = req.tgUser.id.toString();
-        if (game.hostId !== userId) return res.json({ ok: false, error: 'Only host can start' });
-        if (game.players.length < 2) return res.json({ ok: false, error: 'Need at least 2 players' });
-
-        // Kick 3rd player in 4-player mode
-        if (game.maxPlayers === 4 && game.players.length === 3) {
-            const kicked = game.players.pop(); game.scores.pop();
-            if (global._tgClient && game.chatId) {
-                try { await global._tgClient.sendMessage(game.chatId, { message: `😔 Sorry <b>${kicked.name}</b>, need 2 or 4 players. Join next round!` }); } catch (e) {}
-            }
-        }
-
-        if (game._timer) { clearTimeout(game._timer); game._timer = null; }
-        if (game._autoStart) { clearTimeout(game._autoStart); game._autoStart = null; }
-
-        // Charge all
-        for (const p of game.players) {
-            let u = await User.findOne({ userId: p.userId }) || await User.create({ userId: p.userId });
-            u.wallet -= game.bet; await u.save();
-        }
-
+        if (!game) return res.json({ ok: false, error: 'Not found' });
+        if (game.status !== 'lobby') return res.json({ ok: false, error: 'Already started' });
+        if (game.hostId !== req.tgUser.id.toString()) return res.json({ ok: false, error: 'Only host' });
+        if (game.players.length < 2) return res.json({ ok: false, error: 'Need 2+' });
+        if (game.players.length === 3) { const k = game.players.pop(); game.scores.pop(); }
+        if (game._timer) clearTimeout(game._timer);
+        if (game._autoStart) clearTimeout(game._autoStart);
+        for (const p of game.players) { let u = await User.findOne({userId:p.userId})||await User.create({userId:p.userId}); u.wallet-=game.bet; await u.save(); }
         game.start();
-
-        if (global._tgClient && game.chatId) {
-            const { getBotUsername } = require('./utils/miniAppButton');
-            const playUrl = `https://t.me/${getBotUsername()}?startapp=carrom_${gameId.replace(/:/g, '_0_')}`;
-            const pot = game.bet * game.players.length;
-            const pl = game.players.map((p, i) => `${i + 1}. ${p.name}`).join('\n');
-            try {
-                await global._tgClient.sendMessage(game.chatId, {
-                    message: `🎯 <b>CARROM POOL — GAME ON!</b>\nPot: <b>$${pot}</b>\n\n${pl}`,
-                    buttons: new (require('telegram').Api).ReplyInlineMarkup({ rows: [
-                        new (require('telegram').Api).KeyboardButtonRow({ buttons: [
-                            new (require('telegram').Api).KeyboardButtonUrl({ text: "🎮 Play / Watch", url: playUrl })
-                        ] })
-                    ] })
-                });
-            } catch (e) {}
-        }
-
-        res.json({ ok: true, state: game.getState(userId) });
-    } catch (err) {
-        console.error('[API] /carrom/start error:', err);
-        res.status(500).json({ ok: false, error: 'Server error' });
-    }
+        res.json({ ok: true, state: game.getState(req.tgUser.id.toString()) });
+    } catch (err) { console.error('[API] carrom/start:', err.message); res.status(500).json({ ok: false, error: 'Error' }); }
 });
 
-// ── GET /carrom/state ──
 app.get('/carrom/state', auth, async (req, res) => {
     try {
-        const { gameId } = req.query;
-        if (!gameId) return res.json({ ok: false, error: 'Missing gameId' });
         const sessions = require('./games/sessions');
-        const game = sessions.get(gameId);
-        if (!game || !game.getState) {
-            console.log('[API] /carrom/state: Game not found:', gameId);
-            return res.json({ ok: false, error: 'Game not found' });
-        }
-        const userId = req.tgUser.id.toString();
-        res.json({ ok: true, state: game.getState(userId) });
-    } catch (err) {
-        console.error('[API] /carrom/state error:', err);
-        res.status(500).json({ ok: false, error: 'Server error' });
-    }
+        const game = sessions.get(req.query.gameId);
+        if (!game?.getState) return res.json({ ok: false, error: 'Not found' });
+        res.json({ ok: true, state: game.getState(req.tgUser.id.toString()) });
+    } catch (err) { res.status(500).json({ ok: false, error: 'Error' }); }
 });
 
-// ── POST /carrom/move — Move striker along baseline before shooting ──
 app.post('/carrom/move', auth, async (req, res) => {
     try {
-        const { gameId, x } = req.body;
-        if (!gameId) return res.json({ ok: false, error: 'Missing gameId' });
         const sessions = require('./games/sessions');
-        const game = sessions.get(gameId);
-        if (!game || !game.moveStriker) return res.json({ ok: false, error: 'Game not found' });
-        const userId = req.tgUser.id.toString();
-        const result = game.moveStriker(userId, x);
-        if (result.error) return res.json({ ok: false, error: result.error });
-        res.json({ ok: true });
-    } catch (err) {
-        res.status(500).json({ ok: false, error: 'Server error' });
-    }
+        const game = sessions.get(req.body.gameId);
+        if (!game?.moveStriker) return res.json({ ok: false, error: 'Not found' });
+        const r = game.moveStriker(req.tgUser.id.toString(), req.body.x);
+        res.json(r.error ? { ok: false, error: r.error } : { ok: true });
+    } catch (err) { res.status(500).json({ ok: false, error: 'Error' }); }
 });
 
-// ── POST /carrom/shoot ──
 app.post('/carrom/shoot', auth, async (req, res) => {
     try {
-        const { gameId, vx, vy } = req.body;
-        if (!gameId) return res.json({ ok: false, error: 'Missing gameId' });
         const sessions = require('./games/sessions');
         const leveling = require('./utils/leveling');
-        const game = sessions.get(gameId);
-        if (!game || !game.shoot) {
-            console.log('[API] /carrom/shoot: Game not found:', gameId);
-            return res.json({ ok: false, error: 'Game not found' });
-        }
-        const userId = req.tgUser.id.toString();
-        const result = game.shoot(userId, vx, vy);
-        if (result.error) return res.json({ ok: false, error: result.error });
-
+        const game = sessions.get(req.body.gameId);
+        if (!game?.shoot) return res.json({ ok: false, error: 'Not found' });
+        const r = game.shoot(req.tgUser.id.toString(), req.body.vx, req.body.vy);
+        if (r.error) return res.json({ ok: false, error: r.error });
         if (game.status === 'ended') {
             const winners = game.getWinnerPlayers();
             const pot = game.bet * game.players.length;
             const share = Math.floor(pot / winners.length);
-            for (const wp of winners) {
-                let w = await User.findOne({ userId: wp.userId }) || await User.create({ userId: wp.userId });
-                w.wallet += share;
-                await leveling.addXP(wp.userId, 200);
-                await w.save();
-            }
-            const winNames = winners.map(w => w.name).join(' & ');
-            if (global._tgClient && game.chatId) {
-                try { await global._tgClient.sendMessage(game.chatId, { message: `🏆 <b>CARROM — GAME OVER!</b>\n\n${winNames} win <b>$${pot}</b>! 🎯` }); } catch (e) {}
-            }
-            sessions.delete(gameId);
+            for (const w of winners) { let u = await User.findOne({userId:w.userId})||await User.create({userId:w.userId}); u.wallet+=share; await leveling.addXP(w.userId,200); await u.save(); }
+            if (global._tgClient && game.chatId) try { await global._tgClient.sendMessage(game.chatId, { message: `🏆 <b>CARROM OVER!</b> ${winners.map(w=>w.name).join(' & ')} win <b>$${pot}</b>!` }); } catch {}
+            setTimeout(() => sessions.delete(req.body.gameId), 3000);
         }
-        res.json({ ok: true, state: game.getState(userId) });
-    } catch (err) {
-        console.error('[API] /carrom/shoot error:', err);
-        res.status(500).json({ ok: false, error: 'Server error' });
-    }
+        res.json({ ok: true, state: game.getState(req.tgUser.id.toString()) });
+    } catch (err) { console.error('[API] carrom/shoot:', err.message); res.status(500).json({ ok: false, error: 'Error' }); }
 });
 
 // ── Card Web Game API ──
 app.get('/wcards/state', auth, async (req, res) => {
     try {
-        const { gameId } = req.query;
         const sessions = require('./games/sessions');
-        const game = sessions.get(gameId);
-        if (!game || !game.getState) return res.json({ ok: false, error: 'Game not found' });
+        const game = sessions.get(req.query.gameId);
+        if (!game?.getState) return res.json({ ok: false, error: 'Not found' });
         res.json({ ok: true, state: game.getState(req.tgUser.id.toString()) });
-    } catch (err) { console.error('[API] wcards/state:', err); res.status(500).json({ ok: false, error: 'Error' }); }
+    } catch (err) { res.status(500).json({ ok: false, error: 'Error' }); }
 });
 
 app.post('/wcards/start', auth, async (req, res) => {
     try {
-        const { gameId } = req.body;
         const sessions = require('./games/sessions');
-        const game = sessions.get(gameId);
-        if (!game) return res.json({ ok: false, error: 'Game not found' });
+        const game = sessions.get(req.body.gameId);
+        if (!game) return res.json({ ok: false, error: 'Not found' });
         if (game.hostId !== req.tgUser.id.toString()) return res.json({ ok: false, error: 'Only host' });
-        if (!game.start()) return res.json({ ok: false, error: 'Need 2+ players' });
-        if (game._timer) { clearTimeout(game._timer); game._timer = null; }
-        if (game._autoStart) { clearTimeout(game._autoStart); game._autoStart = null; }
-        // Charge
-        for (const p of game.players) {
-            let u = await User.findOne({ userId: p.userId }) || await User.create({ userId: p.userId });
-            u.wallet -= game.bet; await u.save();
-        }
+        if (!game.start()) return res.json({ ok: false, error: 'Need 2+' });
+        if (game._timer) clearTimeout(game._timer);
+        if (game._autoStart) clearTimeout(game._autoStart);
+        for (const p of game.players) { let u = await User.findOne({userId:p.userId})||await User.create({userId:p.userId}); u.wallet-=game.bet; await u.save(); }
         res.json({ ok: true, state: game.getState(req.tgUser.id.toString()) });
-    } catch (err) { console.error('[API] wcards/start:', err); res.status(500).json({ ok: false, error: 'Error' }); }
+    } catch (err) { res.status(500).json({ ok: false, error: 'Error' }); }
 });
 
 app.post('/wcards/play', auth, async (req, res) => {
     try {
-        const { gameId, cardIndex } = req.body;
         const sessions = require('./games/sessions');
         const leveling = require('./utils/leveling');
-        const game = sessions.get(gameId);
-        if (!game) return res.json({ ok: false, error: 'Game not found' });
-        const userId = req.tgUser.id.toString();
-        const result = game.playCard(userId, cardIndex);
-        if (result.error) return res.json({ ok: false, error: result.error });
-
-        // If game ended, pay out
+        const game = sessions.get(req.body.gameId);
+        if (!game) return res.json({ ok: false, error: 'Not found' });
+        const r = game.playCard(req.tgUser.id.toString(), req.body.cardIndex);
+        if (r.error) return res.json({ ok: false, error: r.error });
         if (game.status === 'ended') {
             const winners = game.getWinners();
             const pot = game.bet * game.players.length;
             const share = Math.floor(pot / winners.length);
-            for (const w of winners) {
-                let u = await User.findOne({ userId: w.userId }) || await User.create({ userId: w.userId });
-                u.wallet += share;
-                await leveling.addXP(w.userId, 150);
-                await u.save();
-            }
-            const wNames = winners.map(w => w.name).join(' & ');
-            if (global._tgClient && game.chatId) {
-                try { await global._tgClient.sendMessage(game.chatId, { message: `🃏 <b>CARD GAME — OVER!</b>\n\n🏆 ${wNames} wins <b>$${pot}</b>!` }); } catch (e) {}
-            }
-            setTimeout(() => sessions.delete(gameId), 5000);
+            for (const w of winners) { let u = await User.findOne({userId:w.userId})||await User.create({userId:w.userId}); u.wallet+=share; await leveling.addXP(w.userId,150); await u.save(); }
+            if (global._tgClient && game.chatId) try { await global._tgClient.sendMessage(game.chatId, { message: `🃏 <b>CARDS OVER!</b> ${winners.map(w=>w.name).join(' & ')} win <b>$${pot}</b>!` }); } catch {}
+            setTimeout(() => sessions.delete(req.body.gameId), 5000);
         }
-
-        res.json({ ok: true, state: game.getState(userId) });
-    } catch (err) { console.error('[API] wcards/play:', err); res.status(500).json({ ok: false, error: 'Error' }); }
+        res.json({ ok: true, state: game.getState(req.tgUser.id.toString()) });
+    } catch (err) { res.status(500).json({ ok: false, error: 'Error' }); }
 });
 
 app.post('/wcards/next', auth, async (req, res) => {
     try {
-        const { gameId } = req.body;
         const sessions = require('./games/sessions');
-        const game = sessions.get(gameId);
-        if (!game) return res.json({ ok: false, error: 'Game not found' });
+        const game = sessions.get(req.body.gameId);
+        if (!game) return res.json({ ok: false, error: 'Not found' });
         game.nextRound();
         res.json({ ok: true, state: game.getState(req.tgUser.id.toString()) });
     } catch (err) { res.status(500).json({ ok: false, error: 'Error' }); }
 });
 
-// ── Compat: GET /daily/status ──
-app.get('/daily/status', auth, async (req, res) => {
-    const userId = req.tgUser.id.toString();
-    const user = await User.findOne({ userId });
-    const now = new Date();
-    const todayStr = now.toISOString().split('T')[0];
-    if (!user) return res.json({ canClaim: true, hoursLeft: null });
-    const lastClaim = user.lastDaily;
-    if (!lastClaim) return res.json({ canClaim: true, hoursLeft: null });
-    const lastStr = lastClaim.toISOString().split('T')[0];
-    if (lastStr !== todayStr) return res.json({ canClaim: true, hoursLeft: null });
-    return res.json({ canClaim: false, hoursLeft: 24 });
-});
-
 // ── Start ──
-const PORT = parseInt(process.env.PORT || process.env.API_PORT || '7860');
-function startApi() {
-    app.listen(PORT, () => console.log(`[API] Listening on port ${PORT}`));
-}
-
+const PORT = parseInt(process.env.PORT || '7860');
+function startApi() { app.listen(PORT, () => console.log(`[API] Port ${PORT}`)); }
 module.exports = { startApi };

bot.js

@@ -23,7 +23,6 @@ const inlineHandler = require('./handlers/inlineHandler');
 const boardGames = require('./handlers/boardGames');
 const boardHandler = require('./handlers/boardHandler');
 const blackjack = require('./handlers/blackjack');
-const cardGame = require('./handlers/cardGameHandler');
 const strategy = require('./handlers/strategyGames');
 const shopHandler = require('./handlers/shop');
 const admin = require('./handlers/admin');
@@ -182,8 +181,7 @@ const MP_FALLBACK = "⚠️ This command only works in groups! Add me to a group
                 "🎲 /dice <bet> — Dice duel\n" +
                 "🎯 /carrom <bet> — Carrom Pool\n" +
                 "🔓 /hack <bet> <len> — PIN hack\n" +
-                "🃏 /cards <bet> — Card flip (text)\n" +
-                "🃏 /wcards <bet> — Card game (Mini App)\n\n" +
+                "🃏 /cards <bet> — Card Game\n\n" +
                 "<b>🎰 Solo Casino</b>\n" +
                 "/bj &lt;bet&gt; — Blackjack\n" +
                 "/slots — Slots | /mines — Mines\n" +
@@ -248,18 +246,15 @@ const MP_FALLBACK = "⚠️ This command only works in groups! Add me to a group
         if (cmdStart("/xox", text)) { if (requireGroup(event) && await isAlive(event)) await boardGames.startXOX(client, event); }
         if (cmdStart("/c4", text)) { if (requireGroup(event) && await isAlive(event)) await boardGames.startC4(client, event); }
         if (cmdStart("/dice", text)) { if (requireGroup(event) && await isAlive(event)) await games.startDice(client, event); }
-        if (cmdStart("/wcards", text)) { if (requireGroup(event) && await isAlive(event)) await webCards.startWebCards(client, event); }
+        if (cmdStart("/cards", text) || cmdStart("/wcards", text)) { if (requireGroup(event) && await isAlive(event)) await webCards.startWebCards(client, event); }
         if (cmdStart("/carrom", text)) { if (requireGroup(event) && await isAlive(event)) await carrom.startCarrom(client, event); }
-        if (cmdStart("/cards", text)) { if (requireGroup(event) && await isAlive(event)) await cardGame.initCardGame(client, event); }
         if (cmdStart("/hack", text)) { if (requireGroup(event) && await isAlive(event)) await multiHack.initHack(client, event); }
         if (cmd("/join", text)) {
             if (isGroupChat(event.chatId)) {
                 await multiHack.joinHack(client, event);
-                await cardGame.joinCardGame(client, event);
             }
         }
         if (cmdStart("/guess", text)) await multiHack.processGuess(client, event);
-        if (cmdStart("/flip", text)) await cardGame.processFlip(client, event);
         if (cmd("/surrender", text)) await strategy.surrender(client, event);
 
     }, new NewMessage({}));

scripts/downloadGifs.js

@@ -1,135 +1,56 @@
 #!/usr/bin/env node
-/**
- * Downloads GIFs from Giphy API for each shop item.
- * Run during Docker build or manually: node scripts/downloadGifs.js
- * 
- * Uses GIPHY_API_KEY env var or falls back to hardcoded key.
- * Downloads 5 GIFs per item into ./gifs/<itemDir>/0.gif, 1.gif, etc.
- */
-
 const https = require('https');
-const http = require('http');
 const fs = require('fs');
 const path = require('path');
 
 const API_KEY = process.env.GIPHY_API_KEY || 'Ei3iNGXxdCwjwyxwvSaLq7BgNaOLPFEh';
 const GIFS_PER_ITEM = 5;
-
-// Search terms mapped to each shop item gifDir
 const SEARCH_MAP = {
-    'rose':      'rose flower',
-    'teddy':     'teddy bear cute',
-    'ring':      'diamond ring',
-    'crown':     'crown king queen',
-    'chocolate': 'chocolate candy',
-    'star':      'star gold sparkle',
-    'heart':     'heart love red',
-    'trophy':    'trophy cup winner',
-    'fire':      'fire flame',
-    'rocket':    'rocket launch',
+    'rose':'rose flower','teddy':'teddy bear cute','ring':'diamond ring',
+    'crown':'crown king queen','chocolate':'chocolate candy','star':'star gold sparkle',
+    'heart':'heart love red','trophy':'trophy cup winner','fire':'fire flame','rocket':'rocket launch',
 };
-
 const GIFS_DIR = path.join(__dirname, '..', 'gifs');
 
 function fetch(url) {
     return new Promise((resolve, reject) => {
-        const client = url.startsWith('https') ? https : http;
-        client.get(url, { headers: { 'User-Agent': 'AlexaGameBot/1.0' } }, (res) => {
-            // Follow redirects
-            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        const client = url.startsWith('https') ? https : require('http');
+        client.get(url, { headers: { 'User-Agent': 'Bot/1.0' } }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location)
                 return fetch(res.headers.location).then(resolve).catch(reject);
-            }
-            const chunks = [];
-            res.on('data', c => chunks.push(c));
-            res.on('end', () => resolve(Buffer.concat(chunks)));
-            res.on('error', reject);
+            const chunks = []; res.on('data', c => chunks.push(c));
+            res.on('end', () => resolve(Buffer.concat(chunks))); res.on('error', reject);
         }).on('error', reject);
     });
 }
 
-async function searchGiphy(query, limit) {
-    const url = `https://api.giphy.com/v1/gifs/search?api_key=${API_KEY}&q=${encodeURIComponent(query)}&limit=${limit}&rating=g&lang=en`;
-    const data = await fetch(url);
-    const json = JSON.parse(data.toString());
-    if (!json.data || json.data.length === 0) {
-        console.log(`  ⚠ No results for "${query}"`);
-        return [];
-    }
-    // Get the downsized GIF URLs (smaller, good for Telegram)
-    return json.data.map(g => {
-        // Prefer fixed_height_small or downsized
-        const img = g.images;
-        return img.fixed_height_small?.url || img.downsized?.url || img.original?.url;
-    }).filter(Boolean);
-}
-
-async function downloadFile(url, dest) {
-    const data = await fetch(url);
-    fs.writeFileSync(dest, data);
-}
-
 async function main() {
     console.log('🎬 Downloading GIFs from Giphy...');
-    console.log(`   API Key: ${API_KEY.slice(0, 8)}...`);
-    console.log(`   GIFs per item: ${GIFS_PER_ITEM}`);
-    console.log(`   Output: ${GIFS_DIR}\n`);
-
-    // Create base dir
     if (!fs.existsSync(GIFS_DIR)) fs.mkdirSync(GIFS_DIR, { recursive: true });
-
     for (const [dir, query] of Object.entries(SEARCH_MAP)) {
         const itemDir = path.join(GIFS_DIR, dir);
         if (!fs.existsSync(itemDir)) fs.mkdirSync(itemDir, { recursive: true });
-
-        // Skip if already has enough GIFs
         const existing = fs.readdirSync(itemDir).filter(f => f.endsWith('.gif'));
-        if (existing.length >= GIFS_PER_ITEM) {
-            console.log(`✅ ${dir}/ — already has ${existing.length} GIFs, skipping`);
-            continue;
-        }
-
-        console.log(`📥 ${dir}/ — searching "${query}"...`);
+        if (existing.length >= GIFS_PER_ITEM) { console.log(`✅ ${dir}/ — ${existing.length} GIFs`); continue; }
+        console.log(`📥 ${dir}/ — "${query}"...`);
         try {
-            const urls = await searchGiphy(query, GIFS_PER_ITEM);
-            let downloaded = 0;
-            for (let i = 0; i < urls.length && downloaded < GIFS_PER_ITEM; i++) {
-                const dest = path.join(itemDir, `${downloaded}.gif`);
+            const data = await fetch(`https://api.giphy.com/v1/gifs/search?api_key=${API_KEY}&q=${encodeURIComponent(query)}&limit=${GIFS_PER_ITEM}&rating=g`);
+            const json = JSON.parse(data.toString());
+            if (!json.data?.length) { console.log(`  ⚠ No results`); continue; }
+            let dl = 0;
+            for (let i = 0; i < json.data.length && dl < GIFS_PER_ITEM; i++) {
+                const url = json.data[i].images?.fixed_height_small?.url || json.data[i].images?.downsized?.url;
+                if (!url) continue;
                 try {
-                    await downloadFile(urls[i], dest);
-                    const size = fs.statSync(dest).size;
-                    if (size < 1000) {
-                        // Too small, probably an error
-                        fs.unlinkSync(dest);
-                        continue;
-                    }
-                    console.log(`   ✅ ${downloaded}.gif (${(size / 1024).toFixed(1)}KB)`);
-                    downloaded++;
-                } catch (e) {
-                    console.log(`   ❌ Failed to download: ${e.message}`);
-                }
+                    const gif = await fetch(url);
+                    if (gif.length < 1000) continue;
+                    fs.writeFileSync(path.join(itemDir, `${dl}.gif`), gif);
+                    console.log(`  ✅ ${dl}.gif (${(gif.length/1024).toFixed(1)}KB)`);
+                    dl++;
+                } catch (e) { console.log(`  ❌ ${e.message}`); }
             }
-            if (downloaded === 0) {
-                console.log(`   ⚠ No GIFs downloaded for ${dir}`);
-            }
-        } catch (e) {
-            console.log(`   ❌ Search failed: ${e.message}`);
-        }
+        } catch (e) { console.log(`  ❌ ${e.message}`); }
     }
-
-    console.log('\n🎉 GIF download complete!');
-
-    // Summary
-    let total = 0;
-    for (const dir of Object.keys(SEARCH_MAP)) {
-        const itemDir = path.join(GIFS_DIR, dir);
-        const count = fs.existsSync(itemDir) ? fs.readdirSync(itemDir).filter(f => f.endsWith('.gif')).length : 0;
-        total += count;
-        console.log(`   ${dir}: ${count} GIFs`);
-    }
-    console.log(`   Total: ${total} GIFs`);
+    console.log('🎉 Done!');
 }
-
-main().catch(e => {
-    console.error('Fatal error:', e.message);
-    process.exit(0); // Don't fail the build
-});
+main().catch(e => { console.error(e.message); process.exit(0); });