apexbot 1.0.0

package/dist/gateway/index.js

@@ -0,0 +1,303 @@
+"use strict";
+/**
+ * ApexBot Gateway - Central control plane
+ * Similar to Clawdbot's Gateway architecture
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gateway = void 0;
+const ws_1 = require("ws");
+const http_1 = __importDefault(require("http"));
+const eventBus_1 = require("../core/eventBus");
+const sessionManager_1 = require("../sessions/sessionManager");
+const channelManager_1 = require("../channels/channelManager");
+const agentManager_1 = require("../agent/agentManager");
+const dashboard_1 = require("./dashboard");
+class Gateway {
+    config;
+    server = null;
+    wss = null;
+    clients = new Map();
+    sessions;
+    channels;
+    agents;
+    constructor(config = {}) {
+        this.config = {
+            port: config.port || 18789,
+            host: config.host || '127.0.0.1',
+            token: config.token,
+            verbose: config.verbose || false,
+        };
+        this.sessions = new sessionManager_1.SessionManager();
+        this.channels = new channelManager_1.ChannelManager(this);
+        this.agents = new agentManager_1.AgentManager();
+        this.setupEventHandlers();
+    }
+    setupEventHandlers() {
+        // Route incoming messages to agent
+        (0, eventBus_1.on)('channel:message', async (msg) => {
+            if (this.config.verbose) {
+                console.log(`[Gateway] Message from ${msg.channel}:${msg.from}: ${msg.text?.slice(0, 50)}...`);
+            }
+            // Get or create session
+            const session = this.sessions.getOrCreate(msg.channel, msg.from, msg.isGroup);
+            // Process with agent
+            const response = await this.agents.process(session, msg);
+            // Send response back
+            if (response) {
+                (0, eventBus_1.emit)('channel:send', {
+                    channel: msg.channel,
+                    to: msg.from,
+                    text: response.text,
+                    replyTo: msg.id,
+                });
+            }
+        });
+        // Handle outgoing messages
+        (0, eventBus_1.on)('channel:send', async (msg) => {
+            await this.channels.send(msg.channel, msg.to, msg.text, msg.replyTo);
+        });
+    }
+    async start() {
+        // Create HTTP server for WebSocket and REST API
+        this.server = http_1.default.createServer((req, res) => {
+            this.handleHttpRequest(req, res);
+        });
+        // Create WebSocket server
+        this.wss = new ws_1.WebSocketServer({ server: this.server });
+        this.wss.on('connection', (ws, req) => this.handleWsConnection(ws, req));
+        // Start listening
+        return new Promise((resolve) => {
+            this.server.listen(this.config.port, this.config.host, () => {
+                console.log(`🚀 Gateway running at http://${this.config.host}:${this.config.port}`);
+                console.log(`📡 WebSocket at ws://${this.config.host}:${this.config.port}`);
+                resolve();
+            });
+        });
+    }
+    handleHttpRequest(req, res) {
+        const url = new URL(req.url || '/', `http://${req.headers.host}`);
+        // CORS headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        // Public endpoints (no auth required)
+        const publicPaths = ['/', '/health', '/chat', '/ui'];
+        const isPublic = publicPaths.some(p => url.pathname === p || url.pathname.startsWith('/chat'));
+        // Auth check for protected endpoints
+        if (!isPublic && this.config.token) {
+            const auth = req.headers.authorization;
+            if (auth !== `Bearer ${this.config.token}`) {
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Unauthorized' }));
+                return;
+            }
+        }
+        // Routes
+        switch (url.pathname) {
+            case '/':
+            case '/health':
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    status: 'ok',
+                    version: '0.2.0',
+                    uptime: process.uptime(),
+                    channels: this.channels.getStatus(),
+                    sessions: this.sessions.count(),
+                }));
+                break;
+            case '/api/status':
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    gateway: { host: this.config.host, port: this.config.port },
+                    channels: this.channels.getStatus(),
+                    sessions: this.sessions.getAll().map(s => ({
+                        id: s.id,
+                        channel: s.channel,
+                        peer: s.peer,
+                        messageCount: s.messageCount,
+                    })),
+                    agents: this.agents.getStatus(),
+                }));
+                break;
+            case '/api/sessions':
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(this.sessions.getAll()));
+                break;
+            default:
+                // Serve Dashboard UI
+                if (url.pathname.startsWith('/chat') || url.pathname === '/ui' || url.pathname === '/dashboard') {
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end((0, dashboard_1.getDashboardHtml)());
+                }
+                else {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Not found' }));
+                }
+        }
+    }
+    handleWsConnection(ws, req) {
+        const clientId = Math.random().toString(36).substring(7);
+        this.clients.set(clientId, ws);
+        if (this.config.verbose) {
+            console.log(`[Gateway] WS client connected: ${clientId}`);
+        }
+        ws.on('message', async (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                await this.handleWsMessage(clientId, ws, msg);
+            }
+            catch (e) {
+                ws.send(JSON.stringify({ error: 'Invalid message format' }));
+            }
+        });
+        ws.on('close', () => {
+            this.clients.delete(clientId);
+            if (this.config.verbose) {
+                console.log(`[Gateway] WS client disconnected: ${clientId}`);
+            }
+        });
+        // Send welcome
+        ws.send(JSON.stringify({
+            type: 'connected',
+            clientId,
+            version: '0.2.0',
+        }));
+    }
+    async handleWsMessage(clientId, ws, msg) {
+        switch (msg.type) {
+            case 'ping':
+                ws.send(JSON.stringify({ type: 'pong' }));
+                break;
+            case 'chat':
+                // WebChat message
+                (0, eventBus_1.emit)('channel:message', {
+                    channel: 'webchat',
+                    from: clientId,
+                    text: msg.text,
+                    id: msg.id || Date.now().toString(),
+                    isGroup: false,
+                });
+                break;
+            case 'subscribe':
+                // Subscribe to events
+                // TODO: implement event subscriptions
+                break;
+            case 'status':
+                ws.send(JSON.stringify({
+                    type: 'status',
+                    channels: this.channels.getStatus(),
+                    sessions: this.sessions.count(),
+                }));
+                break;
+            default:
+                ws.send(JSON.stringify({ error: `Unknown message type: ${msg.type}` }));
+        }
+    }
+    getWebChatHtml() {
+        return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>ApexBot - WebChat</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #1a1a2e; color: #eee; height: 100vh; display: flex; flex-direction: column; }
+    header { background: #16213e; padding: 1rem; display: flex; align-items: center; gap: 1rem; }
+    header h1 { font-size: 1.5rem; }
+    .status { font-size: 0.8rem; color: #4ade80; }
+    #messages { flex: 1; overflow-y: auto; padding: 1rem; display: flex; flex-direction: column; gap: 0.5rem; }
+    .message { max-width: 80%; padding: 0.75rem 1rem; border-radius: 1rem; }
+    .message.user { background: #0f3460; align-self: flex-end; }
+    .message.bot { background: #16213e; align-self: flex-start; }
+    .message .meta { font-size: 0.7rem; color: #888; margin-top: 0.25rem; }
+    #input-area { background: #16213e; padding: 1rem; display: flex; gap: 0.5rem; }
+    #input { flex: 1; padding: 0.75rem 1rem; border: none; border-radius: 1.5rem; background: #1a1a2e; color: #eee; font-size: 1rem; }
+    #input:focus { outline: 2px solid #4ade80; }
+    button { padding: 0.75rem 1.5rem; border: none; border-radius: 1.5rem; background: #4ade80; color: #000; font-weight: bold; cursor: pointer; }
+    button:hover { background: #22c55e; }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>🤖 ApexBot</h1>
+    <span class="status" id="status">Connecting...</span>
+  </header>
+  <div id="messages"></div>
+  <div id="input-area">
+    <input type="text" id="input" placeholder="Type a message..." autocomplete="off">
+    <button onclick="send()">Send</button>
+  </div>
+  <script>
+    const messages = document.getElementById('messages');
+    const input = document.getElementById('input');
+    const status = document.getElementById('status');
+    let ws;
+
+    function connect() {
+      ws = new WebSocket('ws://' + location.host);
+      ws.onopen = () => { status.textContent = '● Connected'; status.style.color = '#4ade80'; };
+      ws.onclose = () => { status.textContent = '● Disconnected'; status.style.color = '#f87171'; setTimeout(connect, 3000); };
+      ws.onmessage = (e) => {
+        const msg = JSON.parse(e.data);
+        if (msg.type === 'chat' || msg.type === 'response') {
+          addMessage(msg.text, 'bot');
+        }
+      };
+    }
+
+    function addMessage(text, type) {
+      const div = document.createElement('div');
+      div.className = 'message ' + type;
+      div.innerHTML = text + '<div class="meta">' + new Date().toLocaleTimeString() + '</div>';
+      messages.appendChild(div);
+      messages.scrollTop = messages.scrollHeight;
+    }
+
+    function send() {
+      const text = input.value.trim();
+      if (!text) return;
+      addMessage(text, 'user');
+      ws.send(JSON.stringify({ type: 'chat', text, id: Date.now().toString() }));
+      input.value = '';
+    }
+
+    input.addEventListener('keypress', (e) => { if (e.key === 'Enter') send(); });
+    connect();
+  </script>
+</body>
+</html>`;
+    }
+    async stop() {
+        await this.channels.disconnectAll();
+        for (const [id, ws] of this.clients) {
+            ws.close();
+        }
+        this.clients.clear();
+        if (this.wss) {
+            this.wss.close();
+        }
+        if (this.server) {
+            this.server.close();
+        }
+        console.log('Gateway stopped');
+    }
+    broadcast(message) {
+        const data = JSON.stringify(message);
+        for (const ws of this.clients.values()) {
+            if (ws.readyState === ws_1.WebSocket.OPEN) {
+                ws.send(data);
+            }
+        }
+    }
+}
+exports.Gateway = Gateway;
+exports.default = Gateway;

package/dist/index.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const decisionEngine_1 = __importDefault(require("./decisionEngine"));
+const manifold_1 = __importDefault(require("./adapters/manifold"));
+const telegram_1 = __importDefault(require("./adapters/telegram"));
+const arbitrage_1 = __importDefault(require("./strategy/arbitrage"));
+const llmChecker_1 = __importDefault(require("./safety/llmChecker"));
+const eventBus_1 = require("./eventBus");
+// ─────────────────────────────────────────────────────────────────
+// Configuration (use env vars in production)
+// ─────────────────────────────────────────────────────────────────
+const config = {
+    // Manifold API
+    manifold: {
+        apiKey: process.env.MANIFOLD_API_KEY || '',
+    },
+    // Telegram Bot
+    telegram: {
+        botToken: process.env.TELEGRAM_BOT_TOKEN || '',
+        allowedUserIds: (process.env.TELEGRAM_ALLOWED_USERS || '')
+            .split(',')
+            .map((s) => parseInt(s.trim(), 10))
+            .filter((n) => !isNaN(n)),
+    },
+    // Decision Engine
+    engine: {
+        bankroll: parseFloat(process.env.STARTING_BANKROLL || '1000'),
+        riskMultiplier: 0.2,
+        minStake: 1,
+        maxStake: 200,
+        rateLimitCapacity: 20,
+        rateLimitRatePerSec: 10,
+        failsafe: {
+            maxConsecutiveLosses: 5,
+            maxDrawdownPct: 0.2,
+        },
+    },
+    // Arbitrage
+    arbitrage: {
+        minProfitThreshold: 2, // M$2 minimum expected profit
+        correlatedPairs: [],
+    },
+    // LLM Safety (optional - requires GOOGLE_API_KEY)
+    safety: {
+        googleApiKey: process.env.GOOGLE_API_KEY || '',
+        enabled: Boolean(process.env.GOOGLE_API_KEY),
+    },
+};
+// ─────────────────────────────────────────────────────────────────
+// Main
+// ─────────────────────────────────────────────────────────────────
+async function main() {
+    console.log('🚀 ApexBot starting...');
+    // Initialize adapters
+    const manifold = new manifold_1.default(config.manifold);
+    const engine = new decisionEngine_1.default(config.engine);
+    let telegram = null;
+    let arbDetector = null;
+    let safetyChecker = null;
+    let tradingEnabled = true;
+    // ─────────────────────────────────────────────────────────────────
+    // Telegram Bot (optional)
+    // ─────────────────────────────────────────────────────────────────
+    if (config.telegram.botToken && config.telegram.allowedUserIds.length > 0) {
+        telegram = new telegram_1.default(config.telegram);
+        // Handle telegram commands
+        (0, eventBus_1.on)('telegram:status_request', async (req) => {
+            const status = `📊 *ApexBot Status*\n` +
+                `Bankroll: M$${engine.getBankroll().toFixed(2)}\n` +
+                `Trading: ${tradingEnabled ? '✅ Active' : '🛑 Stopped'}\n` +
+                `Risk multiplier: ${config.engine.riskMultiplier}`;
+            await telegram.sendTo(req.chatId, status);
+        });
+        (0, eventBus_1.on)('telegram:markets_request', async (req) => {
+            try {
+                const markets = await manifold.getMarkets(10);
+                const list = markets.slice(0, 10).map((m, i) => `${i + 1}. ${m.question.slice(0, 50)}... (${(m.probability * 100).toFixed(0)}%)`).join('\n');
+                await telegram.sendTo(req.chatId, `📈 *Top Markets*\n\n${list}`);
+            }
+            catch (e) {
+                await telegram.sendTo(req.chatId, '❌ Nie udało się pobrać rynków.');
+            }
+        });
+        (0, eventBus_1.on)('telegram:stop_trading', () => {
+            tradingEnabled = false;
+        });
+        (0, eventBus_1.on)('telegram:start_trading', () => {
+            tradingEnabled = true;
+        });
+        (0, eventBus_1.on)('telegram:set_risk', (req) => {
+            config.engine.riskMultiplier = req.riskMultiplier;
+        });
+        telegram.start().catch((e) => {
+            console.error('Telegram bot failed to start:', e);
+        });
+        console.log('🤖 Telegram bot initialized');
+    }
+    else {
+        console.log('⚠️  Telegram not configured (set TELEGRAM_BOT_TOKEN and TELEGRAM_ALLOWED_USERS)');
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // Arbitrage Detector
+    // ─────────────────────────────────────────────────────────────────
+    arbDetector = new arbitrage_1.default(manifold, config.arbitrage);
+    console.log('🔍 Arbitrage detector initialized');
+    // ─────────────────────────────────────────────────────────────────
+    // LLM Safety Checker (optional)
+    // ─────────────────────────────────────────────────────────────────
+    if (config.safety.enabled) {
+        safetyChecker = new llmChecker_1.default({ googleApiKey: config.safety.googleApiKey });
+        console.log('🛡️  LLM safety checker initialized (Gemini)');
+    }
+    else {
+        console.log('⚠️  LLM safety checker not enabled (set GOOGLE_API_KEY)');
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // Event handlers
+    // ─────────────────────────────────────────────────────────────────
+    // Log all strategy alerts
+    (0, eventBus_1.on)('strategy:alert', (msg) => {
+        console.log(`[ALERT] ${msg}`);
+    });
+    // Log arbitrage opportunities
+    (0, eventBus_1.on)('arb:opportunity', (arb) => {
+        console.log(`[ARB] ${arb.details} | Expected profit: M$${arb.expectedProfit.toFixed(2)}`);
+    });
+    // Log safety warnings
+    (0, eventBus_1.on)('safety:warning', (warn) => {
+        console.log(`[SAFETY] Market ${warn.marketId}: ${warn.reason} (score: ${warn.score})`);
+    });
+    // ─────────────────────────────────────────────────────────────────
+    // Main loop: periodic market scan
+    // ─────────────────────────────────────────────────────────────────
+    const scanInterval = 60_000; // 1 minute
+    async function scanMarkets() {
+        if (!tradingEnabled) {
+            console.log('[SCAN] Trading disabled, skipping...');
+            return;
+        }
+        console.log('[SCAN] Fetching markets...');
+        try {
+            const markets = await manifold.getMarkets(50);
+            for (const market of markets) {
+                if (market.isResolved)
+                    continue;
+                // Quick safety check
+                if (safetyChecker) {
+                    const quick = safetyChecker.quickCheck(market.question, market.description);
+                    if (!quick.pass) {
+                        console.log(`[SKIP] ${market.id}: ${quick.issues.join(', ')}`);
+                        continue;
+                    }
+                }
+                // Emit market update for decision engine
+                (0, eventBus_1.emit)('market:update', {
+                    marketId: market.id,
+                    price: market.probability,
+                    probModel: market.probability, // TODO: replace with your own model
+                    description: market.question,
+                    timestamp: Date.now(),
+                });
+            }
+            // Check for arbitrage opportunities
+            if (arbDetector) {
+                await arbDetector.scanAllMarkets(50);
+            }
+        }
+        catch (e) {
+            console.error('[SCAN] Error:', e);
+        }
+    }
+    // Initial scan
+    await scanMarkets();
+    // Periodic scans
+    setInterval(scanMarkets, scanInterval);
+    // ─────────────────────────────────────────────────────────────────
+    // WebSocket connection (real-time updates)
+    // ─────────────────────────────────────────────────────────────────
+    if (config.manifold.apiKey) {
+        manifold.connectWebSocket();
+        console.log('📡 WebSocket connection initiated');
+    }
+    console.log('✅ ApexBot running. Press Ctrl+C to stop.');
+}
+// ─────────────────────────────────────────────────────────────────
+// Entry point
+// ─────────────────────────────────────────────────────────────────
+main().catch((e) => {
+    console.error('Fatal error:', e);
+    process.exit(1);
+});

package/dist/math/ev.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectedValueForBuy = expectedValueForBuy;
+exports.expectedValueForSell = expectedValueForSell;
+/**
+ * Compute Expected Value (EV) per $1 invested when buying a binary share at price `price`.
+ * - price: market price (0..1) you can buy a $1-paying share for
+ * - prob: your estimated true probability of the event (0..1)
+ * EV = prob * (1 - price) + (1 - prob) * (-price) = prob - price
+ * Returns EV in dollars per $1 invested (positive => edge)
+ */
+function expectedValueForBuy(price, prob) {
+    return prob - price;
+}
+/**
+ * EV when selling (shorting) a share: selling (i.e. laying) receives price now and pays $1 on event
+ * For a $1 payout on event, if you sell at price `price`, EV = price - prob
+ */
+function expectedValueForSell(price, prob) {
+    return price - prob;
+}
+exports.default = {
+    expectedValueForBuy,
+    expectedValueForSell,
+};

package/dist/math/kelly.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kellyFraction = kellyFraction;
+/**
+ * Kelly fraction for binary share markets where buying a share costs `price` and pays $1 on win.
+ * We model the bet as: stake S (dollars) -> on win profit = S*(1/price - 1); on loss = -S
+ * b = (1/price - 1) (net odds per dollar staked). q = estimated win probability.
+ * Standard Kelly: f* = (b*q - (1-q)) / b
+ * Returns a fraction of bankroll recommended by (full) Kelly; caller should apply a risk multiplier <1.
+ */
+function kellyFraction(price, prob) {
+    if (price <= 0 || price >= 1)
+        return 0;
+    const b = (1 / price - 1);
+    const q = prob;
+    const numerator = b * q - (1 - q);
+    const f = numerator / b;
+    if (!isFinite(f))
+        return 0;
+    return Math.max(0, f);
+}
+exports.default = {
+    kellyFraction,
+};

package/dist/rateLimiter.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeakyBucket = void 0;
+/**
+ * Simple Leaky Bucket rate limiter for API calls.
+ * capacity: max tokens
+ * leakRate: tokens per second replenished (capacity units per sec)
+ */
+class LeakyBucket {
+    capacity;
+    tokens;
+    leakRate; // tokens per second
+    last;
+    constructor(capacity, leakRate) {
+        this.capacity = capacity;
+        this.tokens = capacity;
+        this.leakRate = leakRate;
+        this.last = Date.now() / 1000;
+    }
+    refill() {
+        const now = Date.now() / 1000;
+        const delta = now - this.last;
+        this.last = now;
+        this.tokens = Math.min(this.capacity, this.tokens + delta * this.leakRate);
+    }
+    tryRemove(cost = 1) {
+        this.refill();
+        if (this.tokens >= cost) {
+            this.tokens -= cost;
+            return true;
+        }
+        return false;
+    }
+    timeUntil(cost = 1) {
+        this.refill();
+        if (this.tokens >= cost)
+            return 0;
+        return (cost - this.tokens) / this.leakRate;
+    }
+}
+exports.LeakyBucket = LeakyBucket;
+exports.default = LeakyBucket;

package/dist/safety/failsafe.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailSafe = void 0;
+class FailSafe {
+    cfg;
+    consecutiveLosses = 0;
+    peakBankroll = 0;
+    constructor(cfg, startingBankroll) {
+        this.cfg = cfg;
+        this.peakBankroll = startingBankroll;
+    }
+    onTradeResult(bankroll, pnl) {
+        if (pnl < 0)
+            this.consecutiveLosses += 1;
+        else
+            this.consecutiveLosses = 0;
+        if (bankroll > this.peakBankroll)
+            this.peakBankroll = bankroll;
+    }
+    shouldStop(bankroll) {
+        if (this.consecutiveLosses >= this.cfg.maxConsecutiveLosses) {
+            return { stop: true, reason: 'max_consecutive_losses' };
+        }
+        const drawdown = (this.peakBankroll - bankroll) / Math.max(1, this.peakBankroll);
+        if (drawdown >= this.cfg.maxDrawdownPct) {
+            return { stop: true, reason: 'max_drawdown' };
+        }
+        return { stop: false };
+    }
+}
+exports.FailSafe = FailSafe;
+exports.default = FailSafe;