pnpfucius 2.0.0

package/src/daemon/lifecycle.js

@@ -0,0 +1,168 @@
+// Graceful shutdown and signal handling for daemon mode
+// Ensures state is saved and resources are cleaned up
+
+import { agentEvents, AgentEvents } from '../events/emitter.js';
+
+export function setupGracefulShutdown(daemon, options = {}) {
+    const signals = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+    let shuttingDown = false;
+    const timeout = options.timeout || 30000;
+
+    const shutdown = async (signal) => {
+        if (shuttingDown) {
+            console.log('Shutdown already in progress...');
+            return;
+        }
+
+        shuttingDown = true;
+        console.log(`\nReceived ${signal}, shutting down gracefully...`);
+
+        // Set a hard timeout
+        const hardTimeout = setTimeout(() => {
+            console.error('Shutdown timeout exceeded, forcing exit');
+            process.exit(1);
+        }, timeout);
+
+        try {
+            agentEvents.emitTyped(AgentEvents.DAEMON_STOPPED, {
+                signal,
+                reason: 'graceful_shutdown'
+            });
+
+            await daemon.stop();
+            console.log('Daemon stopped successfully');
+
+            clearTimeout(hardTimeout);
+            process.exit(0);
+        } catch (error) {
+            console.error('Error during shutdown:', error.message);
+            clearTimeout(hardTimeout);
+            process.exit(1);
+        }
+    };
+
+    // Register signal handlers
+    for (const signal of signals) {
+        process.on(signal, () => shutdown(signal));
+    }
+
+    // Handle uncaught exceptions
+    process.on('uncaughtException', async (error) => {
+        console.error('Uncaught exception:', error);
+
+        agentEvents.emitTyped(AgentEvents.DAEMON_ERROR, {
+            type: 'uncaughtException',
+            error: error.message,
+            stack: error.stack
+        });
+
+        try {
+            if (daemon.saveState) {
+                await daemon.saveState();
+            }
+        } catch (saveError) {
+            console.error('Failed to save state:', saveError.message);
+        }
+
+        process.exit(1);
+    });
+
+    // Handle unhandled promise rejections
+    process.on('unhandledRejection', async (reason, promise) => {
+        console.error('Unhandled rejection at:', promise, 'reason:', reason);
+
+        agentEvents.emitTyped(AgentEvents.DAEMON_ERROR, {
+            type: 'unhandledRejection',
+            error: String(reason)
+        });
+
+        try {
+            if (daemon.saveState) {
+                await daemon.saveState();
+            }
+        } catch (saveError) {
+            console.error('Failed to save state:', saveError.message);
+        }
+
+        process.exit(1);
+    });
+
+    return {
+        shutdown,
+        isShuttingDown: () => shuttingDown
+    };
+}
+
+// Health check helper for long-running processes
+export class HealthMonitor {
+    constructor(options = {}) {
+        this.checkInterval = options.checkInterval || 60000;
+        this.maxMemoryMB = options.maxMemoryMB || 512;
+        this.onUnhealthy = options.onUnhealthy || null;
+        this.timer = null;
+        this.startTime = Date.now();
+        this.lastCheck = null;
+    }
+
+    start() {
+        this.timer = setInterval(() => this.check(), this.checkInterval);
+        return this;
+    }
+
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        return this;
+    }
+
+    check() {
+        const health = this.getHealth();
+        this.lastCheck = Date.now();
+
+        if (!health.healthy && this.onUnhealthy) {
+            this.onUnhealthy(health);
+        }
+
+        return health;
+    }
+
+    getHealth() {
+        const memUsage = process.memoryUsage();
+        const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
+        const rssMB = Math.round(memUsage.rss / 1024 / 1024);
+
+        const uptime = Date.now() - this.startTime;
+        const memoryOk = heapUsedMB < this.maxMemoryMB;
+
+        return {
+            healthy: memoryOk,
+            uptime,
+            uptimeHuman: this.formatUptime(uptime),
+            memory: {
+                heapUsedMB,
+                rssMB,
+                maxMB: this.maxMemoryMB
+            },
+            lastCheck: this.lastCheck,
+            issues: memoryOk ? [] : ['Memory usage exceeded threshold']
+        };
+    }
+
+    formatUptime(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+
+        if (days > 0) return `${days}d ${hours % 24}h`;
+        if (hours > 0) return `${hours}h ${minutes % 60}m`;
+        if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+        return `${seconds}s`;
+    }
+}
+
+export function createHealthMonitor(options) {
+    return new HealthMonitor(options);
+}

package/src/daemon/scheduler.js

@@ -0,0 +1,252 @@
+// Cron-style scheduling engine for autonomous agent operation
+// Supports both cron expressions and interval strings
+
+import cronParser from 'cron-parser';
+
+export class Scheduler {
+    constructor() {
+        this.tasks = new Map();
+        this.timers = new Map();
+        this.running = false;
+        this.taskRuns = new Map(); // Track execution counts
+    }
+
+    addTask(config) {
+        const { name, schedule, task, runImmediately = false, enabled = true } = config;
+
+        if (!name || !schedule || !task) {
+            throw new Error('Task requires name, schedule, and task function');
+        }
+
+        const parsed = this.parseSchedule(schedule);
+
+        this.tasks.set(name, {
+            schedule: parsed,
+            originalSchedule: schedule,
+            task,
+            runImmediately,
+            enabled,
+            lastRun: null,
+            nextRun: null,
+            runCount: 0,
+            errors: []
+        });
+
+        return this;
+    }
+
+    removeTask(name) {
+        const timer = this.timers.get(name);
+        if (timer) {
+            clearTimeout(timer);
+            this.timers.delete(name);
+        }
+        this.tasks.delete(name);
+        return this;
+    }
+
+    enableTask(name) {
+        const task = this.tasks.get(name);
+        if (task) {
+            task.enabled = true;
+            if (this.running) {
+                this.scheduleNext(name, task);
+            }
+        }
+        return this;
+    }
+
+    disableTask(name) {
+        const task = this.tasks.get(name);
+        if (task) {
+            task.enabled = false;
+            const timer = this.timers.get(name);
+            if (timer) {
+                clearTimeout(timer);
+                this.timers.delete(name);
+            }
+        }
+        return this;
+    }
+
+    parseSchedule(schedule) {
+        // Support cron expressions (5 or 6 fields)
+        if (schedule.includes('*') || schedule.split(' ').length >= 5) {
+            return { type: 'cron', expression: schedule };
+        }
+
+        // Support interval strings like "30s", "5m", "1h", "2d"
+        const match = schedule.match(/^(\d+)(s|m|h|d)$/i);
+        if (match) {
+            const multipliers = {
+                s: 1000,
+                m: 60 * 1000,
+                h: 60 * 60 * 1000,
+                d: 24 * 60 * 60 * 1000
+            };
+            const value = parseInt(match[1], 10);
+            const unit = match[2].toLowerCase();
+            return {
+                type: 'interval',
+                ms: value * multipliers[unit],
+                original: schedule
+            };
+        }
+
+        // Support plain milliseconds
+        const ms = parseInt(schedule, 10);
+        if (!isNaN(ms)) {
+            return { type: 'interval', ms };
+        }
+
+        throw new Error(`Invalid schedule format: ${schedule}. Use cron expression or interval (e.g., "5m", "1h")`);
+    }
+
+    start() {
+        if (this.running) return this;
+
+        this.running = true;
+
+        for (const [name, config] of this.tasks) {
+            if (!config.enabled) continue;
+
+            if (config.runImmediately) {
+                this.executeTask(name, config);
+            }
+            this.scheduleNext(name, config);
+        }
+
+        return this;
+    }
+
+    stop() {
+        this.running = false;
+
+        for (const timer of this.timers.values()) {
+            clearTimeout(timer);
+        }
+        this.timers.clear();
+
+        return this;
+    }
+
+    scheduleNext(name, config) {
+        if (!this.running || !config.enabled) return;
+
+        let delay;
+
+        if (config.schedule.type === 'interval') {
+            delay = config.schedule.ms;
+        } else {
+            try {
+                const interval = cronParser.parseExpression(config.schedule.expression);
+                const nextDate = interval.next().toDate();
+                delay = nextDate.getTime() - Date.now();
+
+                // Ensure minimum delay of 1 second
+                if (delay < 1000) {
+                    delay = 1000;
+                }
+            } catch (error) {
+                console.error(`Invalid cron expression for task ${name}:`, error.message);
+                return;
+            }
+        }
+
+        config.nextRun = Date.now() + delay;
+
+        const timer = setTimeout(async () => {
+            if (!this.running || !config.enabled) return;
+
+            await this.executeTask(name, config);
+            this.scheduleNext(name, config);
+        }, delay);
+
+        this.timers.set(name, timer);
+    }
+
+    async executeTask(name, config) {
+        config.lastRun = Date.now();
+        config.runCount++;
+
+        try {
+            await config.task();
+        } catch (error) {
+            config.errors.push({
+                time: Date.now(),
+                message: error.message
+            });
+
+            // Keep only last 10 errors
+            if (config.errors.length > 10) {
+                config.errors.shift();
+            }
+
+            console.error(`Task "${name}" failed:`, error.message);
+        }
+    }
+
+    // Trigger immediate execution of a task
+    async runNow(name) {
+        const config = this.tasks.get(name);
+        if (!config) {
+            throw new Error(`Task not found: ${name}`);
+        }
+
+        await this.executeTask(name, config);
+        return this;
+    }
+
+    getNextRun(taskName) {
+        const config = this.tasks.get(taskName);
+        if (!config) return null;
+
+        return config.nextRun;
+    }
+
+    getTaskInfo(taskName) {
+        const config = this.tasks.get(taskName);
+        if (!config) return null;
+
+        return {
+            name: taskName,
+            schedule: config.originalSchedule,
+            enabled: config.enabled,
+            lastRun: config.lastRun,
+            nextRun: config.nextRun,
+            runCount: config.runCount,
+            recentErrors: config.errors.slice(-5)
+        };
+    }
+
+    getAllTasks() {
+        const tasks = [];
+        for (const [name, config] of this.tasks) {
+            tasks.push(this.getTaskInfo(name));
+        }
+        return tasks;
+    }
+
+    isRunning() {
+        return this.running;
+    }
+}
+
+export function createScheduler() {
+    return new Scheduler();
+}
+
+// Helper to format next run time
+export function formatNextRun(timestamp) {
+    if (!timestamp) return 'Not scheduled';
+
+    const now = Date.now();
+    const diff = timestamp - now;
+
+    if (diff < 0) return 'Overdue';
+    if (diff < 60000) return `${Math.round(diff / 1000)}s`;
+    if (diff < 3600000) return `${Math.round(diff / 60000)}m`;
+    if (diff < 86400000) return `${Math.round(diff / 3600000)}h`;
+
+    return new Date(timestamp).toLocaleString();
+}

package/src/events/emitter.js

@@ -0,0 +1,147 @@
+// Central event bus for agent status updates and coordination
+// Uses Node.js EventEmitter with typed events
+
+import { EventEmitter } from 'events';
+
+// Event type constants
+export const AgentEvents = {
+    // Daemon lifecycle
+    DAEMON_STARTED: 'daemon:started',
+    DAEMON_STOPPED: 'daemon:stopped',
+    DAEMON_ERROR: 'daemon:error',
+
+    // Cycle events
+    CYCLE_START: 'cycle:start',
+    CYCLE_COMPLETE: 'cycle:complete',
+    CYCLE_ERROR: 'cycle:error',
+
+    // Market events
+    MARKET_CREATED: 'market:created',
+    MARKET_FAILED: 'market:failed',
+    MARKET_RESOLVED: 'market:resolved',
+    MARKET_UPDATED: 'market:updated',
+
+    // Transaction events
+    TX_SENT: 'tx:sent',
+    TX_CONFIRMED: 'tx:confirmed',
+    TX_FAILED: 'tx:failed',
+
+    // News events
+    NEWS_EVENT: 'news:event',
+    NEWS_CHECK_COMPLETE: 'news:check:complete',
+
+    // Webhook events
+    WEBHOOK_RECEIVED: 'webhook:received',
+    WEBHOOK_SERVER_STARTED: 'webhook:server:started',
+    WEBHOOK_SERVER_STOPPED: 'webhook:server:stopped',
+    HELIUS_EVENT: 'helius:event',
+
+    // State events
+    STATE_SAVED: 'state:saved',
+    STATE_RESTORED: 'state:restored',
+
+    // Analytics events
+    STATS_UPDATED: 'stats:updated'
+};
+
+class AgentEventEmitter extends EventEmitter {
+    constructor() {
+        super();
+        this.setMaxListeners(50);
+        this.eventHistory = [];
+        this.maxHistorySize = 100;
+    }
+
+    // Emit with timestamp and optional metadata
+    emitTyped(event, payload = {}) {
+        const eventData = {
+            type: event,
+            timestamp: Date.now(),
+            ...payload
+        };
+
+        // Store in history
+        this.eventHistory.unshift(eventData);
+        if (this.eventHistory.length > this.maxHistorySize) {
+            this.eventHistory.pop();
+        }
+
+        this.emit(event, eventData);
+        return this;
+    }
+
+    // Get recent events of a specific type
+    getRecentEvents(type = null, limit = 10) {
+        let events = this.eventHistory;
+
+        if (type) {
+            events = events.filter(e => e.type === type);
+        }
+
+        return events.slice(0, limit);
+    }
+
+    // Clear event history
+    clearHistory() {
+        this.eventHistory = [];
+    }
+
+    // Subscribe to multiple events
+    onMany(events, handler) {
+        for (const event of events) {
+            this.on(event, handler);
+        }
+        return this;
+    }
+
+    // One-time subscription to multiple events
+    onceAny(events, handler) {
+        const wrappedHandler = (data) => {
+            // Remove all listeners after first event
+            for (const event of events) {
+                this.off(event, wrappedHandler);
+            }
+            handler(data);
+        };
+
+        for (const event of events) {
+            this.on(event, wrappedHandler);
+        }
+        return this;
+    }
+
+    // Wait for a specific event with timeout
+    waitFor(event, timeout = 30000) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.off(event, handler);
+                reject(new Error(`Timeout waiting for event: ${event}`));
+            }, timeout);
+
+            const handler = (data) => {
+                clearTimeout(timer);
+                resolve(data);
+            };
+
+            this.once(event, handler);
+        });
+    }
+}
+
+// Singleton instance
+export const agentEvents = new AgentEventEmitter();
+
+// Helper to create scoped event emitters
+export function createScopedEmitter(scope) {
+    return {
+        emit: (event, payload) => {
+            agentEvents.emitTyped(`${scope}:${event}`, payload);
+        },
+        on: (event, handler) => {
+            agentEvents.on(`${scope}:${event}`, handler);
+        },
+        off: (event, handler) => {
+            agentEvents.off(`${scope}:${event}`, handler);
+        }
+    };
+}