mirror of
https://github.com/multipleof4/KalBot.git
synced 2026-03-17 05:51:02 +00:00
308 lines
9.7 KiB
JavaScript
308 lines
9.7 KiB
JavaScript
import { MarketTracker } from './lib/market/tracker.js';
|
|
import { PaperEngine } from './lib/paper/engine.js';
|
|
import { LiveEngine } from './lib/live/engine.js';
|
|
import { getMarket } from './lib/kalshi/rest.js';
|
|
import { db } from './lib/db.js';
|
|
import { notify } from './lib/notify.js';
|
|
import fs from 'fs';
|
|
import path from 'path';
|
|
import { fileURLToPath, pathToFileURL } from 'url';
|
|
|
|
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
|
const STATE_FILE = '/tmp/kalbot-state.json';
|
|
const LIVE_STATE_FILE = '/tmp/kalbot-live-state.json';
|
|
const HEARTBEAT_MS = 2000;
|
|
const BALANCE_POLL_MS = 30000;
|
|
|
|
let isSettling = false;
|
|
async function lockSettling() {
|
|
while (isSettling) await new Promise((r) => setTimeout(r, 50));
|
|
isSettling = true;
|
|
}
|
|
function unlockSettling() {
|
|
isSettling = false;
|
|
}
|
|
|
|
async function main() {
|
|
console.log('=== Kalbot Worker Starting ===');
|
|
|
|
await db.connect();
|
|
|
|
const paper = new PaperEngine(1000);
|
|
await paper.init();
|
|
|
|
const live = new LiveEngine();
|
|
await live.init();
|
|
|
|
// Dynamically load all strategies
|
|
const strategies = [];
|
|
const strategiesDir = path.join(__dirname, 'lib', 'strategies');
|
|
const stratFiles = fs.readdirSync(strategiesDir).filter((f) => f.endsWith('.js') && f !== 'base.js');
|
|
|
|
for (const file of stratFiles) {
|
|
try {
|
|
const fileUrl = pathToFileURL(path.join(strategiesDir, file)).href;
|
|
const mod = await import(fileUrl);
|
|
for (const key in mod) {
|
|
if (typeof mod[key] === 'function') {
|
|
strategies.push(new mod[key]());
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
console.error(`[Worker] Failed to load strategy ${file}:`, err.message);
|
|
}
|
|
}
|
|
|
|
for (const s of strategies) {
|
|
paper._getAccount(s.name);
|
|
}
|
|
|
|
console.log(`[Worker] Loaded ${strategies.length} strategies: ${strategies.map((s) => s.name).join(', ')}`);
|
|
|
|
let latestMarketState = null;
|
|
|
|
async function pollBalance() {
|
|
try {
|
|
await live.fetchBalance();
|
|
} catch {}
|
|
try {
|
|
await live.fetchPositions();
|
|
} catch {}
|
|
}
|
|
await pollBalance();
|
|
setInterval(pollBalance, BALANCE_POLL_MS);
|
|
|
|
async function processOrphans() {
|
|
if (paper._resetting) return;
|
|
await lockSettling();
|
|
try {
|
|
const { settled, expired } = await paper.checkOrphans(getMarket);
|
|
const settledLive = await live.checkOrphans(getMarket);
|
|
|
|
const allResolved = [...settled, ...expired, ...settledLive];
|
|
|
|
if (allResolved.length > 0) {
|
|
for (const strategy of strategies) {
|
|
for (const trade of allResolved) {
|
|
if (trade.strategy === strategy.name) {
|
|
strategy.onSettlement(trade.result, trade);
|
|
}
|
|
}
|
|
}
|
|
writeState(latestMarketState, paper, live, strategies);
|
|
}
|
|
} catch (e) {
|
|
console.error('[Worker] Orphan check error:', e.message);
|
|
} finally {
|
|
unlockSettling();
|
|
}
|
|
}
|
|
|
|
await processOrphans();
|
|
setInterval(processOrphans, 10000);
|
|
|
|
const tracker = new MarketTracker();
|
|
let heartbeatTimer = null;
|
|
|
|
writeState(latestMarketState, paper, live, strategies);
|
|
|
|
tracker.on('update', async (state) => {
|
|
latestMarketState = state || null;
|
|
writeState(latestMarketState, paper, live, strategies);
|
|
|
|
if (!state || paper._resetting || isSettling) return;
|
|
|
|
for (const strategy of strategies) {
|
|
if (!strategy.enabled) continue;
|
|
|
|
// ===== PAPER TRADING (isolated evaluation) =====
|
|
const paperAcct = paper._getAccount(strategy.name);
|
|
if (paperAcct.openPositions.size === 0) {
|
|
const paperSignal = strategy.evaluate(state, 'paper');
|
|
if (paperSignal) {
|
|
console.log(`[Worker] Paper signal from ${strategy.name}: ${paperSignal.side} @ ${paperSignal.price}¢`);
|
|
await paper.executeTrade(paperSignal, state);
|
|
}
|
|
}
|
|
|
|
// ===== LIVE TRADING (separate evaluation, won't poison paper) =====
|
|
if (live.isStrategyEnabled(strategy.name) && !live.hasOpenPositionForStrategy(strategy.name)) {
|
|
const liveSignal = strategy.evaluate(state, 'live');
|
|
if (liveSignal) {
|
|
console.log(
|
|
`[Worker] LIVE signal from ${strategy.name}: ${liveSignal.side} @ ${liveSignal.price}¢ (max: ${liveSignal.maxPrice}¢)`
|
|
);
|
|
await live.executeTrade(liveSignal, state);
|
|
}
|
|
}
|
|
}
|
|
|
|
writeState(latestMarketState, paper, live, strategies);
|
|
});
|
|
|
|
tracker.on('settled', async ({ ticker, result }) => {
|
|
console.log(`[Worker] Market ${ticker} settled. Result: ${result || 'pending'}`);
|
|
|
|
if (paper._resetting) return;
|
|
|
|
if (result) {
|
|
await lockSettling();
|
|
try {
|
|
const settledPaper = await paper.settle(ticker, result);
|
|
if (settledPaper) {
|
|
for (const strategy of strategies) {
|
|
for (const trade of settledPaper) {
|
|
strategy.onSettlement(trade.result, trade);
|
|
}
|
|
}
|
|
}
|
|
|
|
const settledLive = await live.settle(ticker, result);
|
|
if (settledLive) {
|
|
for (const strategy of strategies) {
|
|
for (const trade of settledLive) {
|
|
strategy.onSettlement(trade.result, trade);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (settledPaper || settledLive) {
|
|
await notify(
|
|
`Market ${ticker} settled: ${result.toUpperCase()}`,
|
|
'Market Settled',
|
|
'default',
|
|
'chart_with_upwards_trend'
|
|
);
|
|
}
|
|
} finally {
|
|
unlockSettling();
|
|
}
|
|
} else {
|
|
// Market rotated but result not posted yet. Recover via orphan reconciliation shortly.
|
|
setTimeout(() => {
|
|
processOrphans().catch((e) => console.error('[Worker] delayed orphan reconcile failed:', e.message));
|
|
}, 4000);
|
|
}
|
|
|
|
writeState(latestMarketState, paper, live, strategies);
|
|
});
|
|
|
|
await tracker.start();
|
|
await notify(`🤖 Kalbot Worker started with ${strategies.length} strats!`, 'Kalbot Online', 'low', 'robot,green_circle');
|
|
|
|
heartbeatTimer = setInterval(() => {
|
|
writeState(latestMarketState, paper, live, strategies);
|
|
}, HEARTBEAT_MS);
|
|
|
|
// Poll for paper reset flag
|
|
setInterval(async () => {
|
|
try {
|
|
if (fs.existsSync('/tmp/kalbot-reset-flag')) {
|
|
fs.unlinkSync('/tmp/kalbot-reset-flag');
|
|
console.log('[Worker] Reset flag detected — resetting all paper data');
|
|
await lockSettling();
|
|
try {
|
|
await paper.resetAll();
|
|
for (const s of strategies) {
|
|
if (s.consecutiveLosses !== undefined) s.consecutiveLosses = 0;
|
|
if (s.currentBetSize !== undefined) s.currentBetSize = s.config.baseBet;
|
|
if (s.round !== undefined) s.round = 0;
|
|
if (s.cycleWins !== undefined) s.cycleWins = 0;
|
|
if (s.cycleLosses !== undefined) s.cycleLosses = 0;
|
|
if (s.totalCycles !== undefined) s.totalCycles = 0;
|
|
if (s._lastTrade) {
|
|
s._lastTrade.paper = { time: 0, ticker: null };
|
|
s._lastTrade.live = { time: 0, ticker: null };
|
|
}
|
|
}
|
|
writeState(latestMarketState, paper, live, strategies);
|
|
await notify('🔄 Paper trading reset by admin', 'Kalbot Reset', 'default', 'recycle');
|
|
} finally {
|
|
unlockSettling();
|
|
}
|
|
}
|
|
} catch {}
|
|
}, 1000);
|
|
|
|
// Poll for live commands (enable/disable/pause/resume)
|
|
setInterval(async () => {
|
|
try {
|
|
if (fs.existsSync('/tmp/kalbot-live-cmd')) {
|
|
const raw = fs.readFileSync('/tmp/kalbot-live-cmd', 'utf-8');
|
|
fs.unlinkSync('/tmp/kalbot-live-cmd');
|
|
const cmd = JSON.parse(raw);
|
|
|
|
switch (cmd.action) {
|
|
case 'enable':
|
|
if (cmd.strategy) {
|
|
live.enableStrategy(cmd.strategy);
|
|
await notify(`⚡ Strategy "${cmd.strategy}" ENABLED for live trading`, 'Live Enable', 'high', 'zap');
|
|
}
|
|
break;
|
|
case 'disable':
|
|
if (cmd.strategy) {
|
|
live.disableStrategy(cmd.strategy);
|
|
await notify(`🔴 Strategy "${cmd.strategy}" DISABLED`, 'Live Disable', 'default', 'red_circle');
|
|
}
|
|
break;
|
|
case 'pause':
|
|
live.pause();
|
|
await notify('⏸ Live trading PAUSED by admin', 'Live Paused', 'urgent', 'double_vertical_bar');
|
|
break;
|
|
case 'resume':
|
|
live.resume();
|
|
await notify('▶️ Live trading RESUMED by admin', 'Live Resumed', 'high', 'arrow_forward');
|
|
break;
|
|
}
|
|
|
|
writeState(latestMarketState, paper, live, strategies);
|
|
}
|
|
} catch {}
|
|
}, 500);
|
|
|
|
console.log('[Worker] Running. Press Ctrl+C to stop.');
|
|
|
|
const shutdown = async (signal) => {
|
|
console.log(`\n[Worker] ${signal} received. Shutting down...`);
|
|
clearInterval(heartbeatTimer);
|
|
tracker.stop();
|
|
await notify('🔴 Kalbot Worker stopped', 'Kalbot Offline', 'high', 'robot,red_circle');
|
|
process.exit(0);
|
|
};
|
|
|
|
process.on('SIGINT', () => shutdown('SIGINT'));
|
|
process.on('SIGTERM', () => shutdown('SIGTERM'));
|
|
}
|
|
|
|
function writeState(marketState, paper, live, strategies) {
|
|
const paperData = {
|
|
market: marketState ? { ...marketState, orderbook: undefined } : null,
|
|
paper: paper.getStats(),
|
|
paperByStrategy: paper.getPerStrategyStats(),
|
|
strategies: strategies.map((s) => s.toJSON()),
|
|
workerUptime: process.uptime(),
|
|
lastUpdate: Date.now()
|
|
};
|
|
|
|
const liveData = {
|
|
market: marketState ? { ...marketState, orderbook: undefined } : null,
|
|
live: live.getStats(),
|
|
strategies: strategies.map((s) => s.toJSON()),
|
|
workerUptime: process.uptime(),
|
|
lastUpdate: Date.now()
|
|
};
|
|
|
|
try {
|
|
fs.writeFileSync(STATE_FILE, JSON.stringify(paperData));
|
|
} catch {}
|
|
try {
|
|
fs.writeFileSync(LIVE_STATE_FILE, JSON.stringify(liveData));
|
|
} catch {}
|
|
}
|
|
|
|
main().catch((err) => {
|
|
console.error('[Worker] Fatal error:', err);
|
|
process.exit(1);
|
|
});
|