kova-node-cli 0.1.0

package/dist/lib/monitor.js

@@ -0,0 +1,105 @@
+import si from 'systeminformation';
+import { logger } from './logger.js';
+export class ResourceMonitor {
+    interval = null;
+    lastStats = {};
+    async start() {
+        // check resources every 30 seconds
+        this.interval = setInterval(() => {
+            this.collectStats();
+        }, 30000);
+        // get initial stats
+        await this.collectStats();
+    }
+    async stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+        }
+    }
+    async collectStats() {
+        try {
+            const [cpu, mem, disk, net, graphics] = await Promise.all([
+                si.currentLoad(),
+                si.mem(),
+                si.fsSize(),
+                si.networkStats(),
+                si.graphics()
+            ]);
+            // collect gpu info
+            const gpus = graphics.controllers
+                .filter((g) => g.vram > 0) // only real gpus with vram
+                .map((g) => ({
+                vendor: g.vendor?.toLowerCase() || 'unknown',
+                model: g.model || 'unknown',
+                vram: Math.round(g.vram / 1024), // convert to gb
+                bus: g.bus || 'pci'
+            }));
+            this.lastStats = {
+                cpu: {
+                    usage: cpu.currentLoad,
+                    cores: cpu.cpus.length,
+                    perCore: cpu.cpus.map(c => c.load)
+                },
+                memory: {
+                    total: Math.round((mem.total / (1024 ** 3)) * 10) / 10, // gb with 1 decimal
+                    available: Math.round((mem.available / (1024 ** 3)) * 10) / 10,
+                    used: Math.round(((mem.total - mem.available) / (1024 ** 3)) * 10) / 10
+                },
+                disk: disk.map(d => ({
+                    fs: d.fs,
+                    total: Math.round((d.size / (1024 ** 3)) * 10) / 10, // gb with 1 decimal
+                    available: Math.round((d.available / (1024 ** 3)) * 10) / 10
+                })),
+                network: {
+                    rx: net[0]?.rx_sec || 0,
+                    tx: net[0]?.tx_sec || 0
+                },
+                gpu: gpus,
+                timestamp: Date.now()
+            };
+            logger.debug(this.lastStats, 'collected system stats');
+        }
+        catch (err) {
+            logger.error({ err }, 'failed to collect stats');
+        }
+    }
+    async getAvailableResources() {
+        // get fresh stats every time
+        await this.collectStats();
+        const stats = this.lastStats;
+        // what can we actually offer based on CURRENT usage
+        const reserved = {
+            memory: 0.5, // keep 0.5gb for system
+            disk: 10 // keep 10gb free
+        };
+        // calculate available CPU based on ACTUAL current load
+        const cpuUsagePercent = stats.cpu.usage || 0;
+        const availableCpuPercent = Math.max(0, 100 - cpuUsagePercent);
+        const availableCpuCores = (availableCpuPercent / 100) * stats.cpu.cores;
+        return {
+            cpu: {
+                cores: stats.cpu.cores,
+                // actual available CPU based on current load
+                available: Math.max(0, Math.round(availableCpuCores * 10) / 10)
+            },
+            memory: {
+                total: stats.memory.total,
+                // actual available memory from system
+                available: Math.max(0, stats.memory.available - reserved.memory)
+            },
+            disk: stats.disk.map((d) => ({
+                path: d.fs,
+                total: d.total,
+                available: Math.max(0, d.available - reserved.disk)
+            })),
+            network: {
+                // just report what we got
+                bandwidth: Math.round((stats.network.rx + stats.network.tx) / 125000) // mbps
+            },
+            gpu: stats.gpu || []
+        };
+    }
+    getStats() {
+        return this.lastStats;
+    }
+}

package/dist/lib/p2p.js

@@ -0,0 +1,186 @@
+// @ts-ignore-next-line
+import Hyperswarm from 'hyperswarm';
+import crypto from 'crypto';
+import { EventEmitter } from 'events';
+import { logger } from './logger.js';
+import { MessageSigner } from './message-signer.js';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+export class P2PNode extends EventEmitter {
+    swarm;
+    topic;
+    connections = new Map();
+    signer;
+    savedKeyPair;
+    constructor(options) {
+        super();
+        this.signer = new MessageSigner();
+        this.topic = crypto.createHash('sha256').update('kova-network').digest();
+        this.savedKeyPair = this.loadKeyPair();
+    }
+    loadKeyPair() {
+        const kovaDir = join(homedir(), '.kova');
+        const keyPath = join(kovaDir, 'node-keypair.json');
+        try {
+            if (existsSync(keyPath)) {
+                const data = JSON.parse(readFileSync(keyPath, 'utf8'));
+                logger.info('loaded existing node keypair');
+                return {
+                    publicKey: Buffer.from(data.publicKey, 'hex'),
+                    secretKey: Buffer.from(data.secretKey, 'hex')
+                };
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, 'failed to load keypair, will generate on start');
+        }
+        return null;
+    }
+    saveKeyPair(keyPair) {
+        const kovaDir = join(homedir(), '.kova');
+        const keyPath = join(kovaDir, 'node-keypair.json');
+        try {
+            if (!existsSync(kovaDir)) {
+                mkdirSync(kovaDir, { recursive: true });
+            }
+            writeFileSync(keyPath, JSON.stringify({
+                publicKey: keyPair.publicKey.toString('hex'),
+                secretKey: keyPair.secretKey.toString('hex')
+            }), { mode: 0o600 });
+            logger.info('saved node keypair');
+        }
+        catch (err) {
+            logger.warn({ err }, 'failed to save keypair');
+        }
+    }
+    async start() {
+        // let hyperswarm generate a proper noise keypair if we don't have one saved
+        const swarmOpts = this.savedKeyPair ? { keyPair: this.savedKeyPair } : {};
+        this.swarm = new Hyperswarm(swarmOpts);
+        // save the generated keypair for next run
+        if (!this.savedKeyPair && this.swarm.keyPair) {
+            this.saveKeyPair(this.swarm.keyPair);
+        }
+        // join the kova network topic
+        this.swarm.join(this.topic, { server: true, client: true });
+        // handle new connections
+        this.swarm.on('connection', (socket, info) => {
+            const connId = info.publicKey.toString('hex').substring(0, 12);
+            this.connections.set(connId, socket);
+            logger.info({ connId, peer: info.publicKey.toString('hex') }, 'new peer connected');
+            // handle incoming messages with size limit
+            const MAX_MESSAGE_SIZE = 1024 * 1024; // 1mb
+            socket.on('data', (data) => {
+                if (data.length > MAX_MESSAGE_SIZE) {
+                    logger.warn({ connId, size: data.length }, 'message too large, dropping');
+                    return;
+                }
+                try {
+                    const signedMessage = JSON.parse(data.toString());
+                    if (!this.signer.verify(signedMessage)) {
+                        logger.warn({ connId }, 'rejected message with bad signature');
+                        return;
+                    }
+                    this.handleMessage(signedMessage.payload, socket);
+                }
+                catch (err) {
+                    logger.debug({ err }, 'failed to parse p2p message');
+                }
+            });
+            socket.on('close', () => {
+                this.connections.delete(connId);
+                logger.debug({ connId }, 'peer disconnected');
+            });
+            socket.on('error', (err) => {
+                logger.debug({ err, connId }, 'peer connection error');
+            });
+        });
+        logger.info({
+            topic: this.topic.toString('hex'),
+            connections: this.connections.size
+        }, 'p2p node started');
+    }
+    handleMessage(message, socket) {
+        switch (message.type) {
+            case 'job-request':
+                this.emit('job-request', message.data);
+                break;
+            case 'job-cancel':
+                this.emit('job-cancel', message.data);
+                break;
+            case 'deployment-manifest':
+                this.emit('deployment-manifest', message.data);
+                break;
+            case 'deployment-close':
+                this.emit('deployment-close', message.data);
+                break;
+            case 'deployment-paused':
+                this.emit('deployment-paused', message.data);
+                break;
+            // shell session handling - forward to deployment executor
+            case 'shell-start':
+                this.emit('shell-start', message.data);
+                break;
+            case 'shell-input':
+                this.emit('shell-input', message.data);
+                break;
+            case 'shell-resize':
+                this.emit('shell-resize', message.data);
+                break;
+            case 'shell-close':
+                this.emit('shell-close', message.data);
+                break;
+            case 'node-announcement':
+                break;
+            default:
+                logger.debug({ type: message.type }, 'unknown message type');
+        }
+    }
+    async stop() {
+        if (this.swarm) {
+            await this.swarm.destroy();
+            logger.info('p2p node stopped');
+        }
+    }
+    async advertiseCapabilities(resources) {
+        const payload = {
+            type: 'node-announcement',
+            data: {
+                nodeId: this.getPeerId(),
+                resources,
+                version: '0.0.1'
+            }
+        };
+        const signedMessage = this.signer.sign(payload);
+        for (const socket of this.connections.values()) {
+            try {
+                socket.write(JSON.stringify(signedMessage));
+            }
+            catch (err) {
+                // connection probably dead
+            }
+        }
+        logger.info({ resources }, 'advertised capabilities to network');
+    }
+    getPeerId() {
+        // use swarm keyPair public key as peer id
+        return this.swarm?.keyPair?.publicKey?.toString('hex').substring(0, 16) || 'unknown';
+    }
+    async sendToOrchestrator(message) {
+        const signedMessage = this.signer.sign(message);
+        for (const socket of this.connections.values()) {
+            try {
+                socket.write(JSON.stringify(signedMessage));
+                return true;
+            }
+            catch (err) {
+                continue;
+            }
+        }
+        return false;
+    }
+    getConnectionCount() {
+        return this.connections.size;
+    }
+}

package/dist/lib/resource-limits.js

@@ -0,0 +1,84 @@
+import si from 'systeminformation';
+import { logger } from './logger.js';
+export class ResourceLimitManager {
+    limits;
+    currentUsage = { cpu: 0, memory: 0, disk: 0 };
+    constructor(limits) {
+        this.limits = limits;
+    }
+    static async createFromOptions(options) {
+        const [cpu, mem] = await Promise.all([
+            si.cpu(),
+            si.mem()
+        ]);
+        const totalCpu = cpu.cores;
+        const totalMemoryGB = mem.total / (1024 ** 3);
+        // use defaults if not specified
+        const limits = {
+            cpu: options.maxCpu ? parseFloat(options.maxCpu) : totalCpu,
+            memory: options.maxMemory ? parseFloat(options.maxMemory) : Math.floor(totalMemoryGB * 0.8),
+            disk: options.maxDisk ? parseFloat(options.maxDisk) : 100
+        };
+        // don't let them set more than they have
+        if (limits.cpu > totalCpu) {
+            logger.warn({ requested: limits.cpu, available: totalCpu }, 'capping cpu to system max');
+            limits.cpu = totalCpu;
+        }
+        if (limits.memory > totalMemoryGB) {
+            logger.warn({ requested: limits.memory, available: totalMemoryGB }, 'capping memory to system max');
+            limits.memory = Math.floor(totalMemoryGB);
+        }
+        logger.info({ limits }, 'resource limits set');
+        return new ResourceLimitManager(limits);
+    }
+    getLimits() {
+        return { ...this.limits };
+    }
+    getAvailableResources() {
+        return {
+            cpu: Math.max(0, this.limits.cpu - this.currentUsage.cpu),
+            memory: Math.max(0, this.limits.memory - this.currentUsage.memory),
+            disk: Math.max(0, this.limits.disk - this.currentUsage.disk)
+        };
+    }
+    canAcceptJob(required) {
+        const available = this.getAvailableResources();
+        const canAccept = required.cpu <= available.cpu &&
+            required.memory <= available.memory &&
+            (!required.disk || required.disk <= available.disk);
+        if (!canAccept) {
+            logger.warn({ required, available }, 'not enough resources');
+        }
+        return canAccept;
+    }
+    allocateResources(jobId, resources) {
+        if (!this.canAcceptJob(resources)) {
+            return false;
+        }
+        this.currentUsage.cpu += resources.cpu;
+        this.currentUsage.memory += resources.memory;
+        if (resources.disk) {
+            this.currentUsage.disk += resources.disk;
+        }
+        logger.info({ jobId, resources }, 'allocated resources');
+        return true;
+    }
+    releaseResources(jobId, resources) {
+        this.currentUsage.cpu = Math.max(0, this.currentUsage.cpu - resources.cpu);
+        this.currentUsage.memory = Math.max(0, this.currentUsage.memory - resources.memory);
+        if (resources.disk) {
+            this.currentUsage.disk = Math.max(0, this.currentUsage.disk - resources.disk);
+        }
+        logger.info({ jobId }, 'released resources');
+    }
+    getCurrentUsage() {
+        return { ...this.currentUsage };
+    }
+    getUsagePercentage() {
+        return {
+            cpu: (this.currentUsage.cpu / this.limits.cpu) * 100,
+            memory: (this.currentUsage.memory / this.limits.memory) * 100,
+            disk: (this.currentUsage.disk / this.limits.disk) * 100
+        };
+    }
+}

package/dist/lib/state.js

@@ -0,0 +1,113 @@
+// persistent state management for the node
+// saves to ~/.kova/node-state.json
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+class StateManager {
+    state = {
+        isRunning: false,
+        totalEarnings: 0,
+        jobsCompleted: 0,
+        jobsFailed: 0,
+        activeDeployments: []
+    };
+    statePath;
+    saveTimeout = null;
+    constructor() {
+        const kovaDir = join(homedir(), '.kova');
+        this.statePath = join(kovaDir, 'node-state.json');
+        // ensure directory exists
+        if (!existsSync(kovaDir)) {
+            mkdirSync(kovaDir, { recursive: true });
+        }
+        // load persisted state
+        this.loadState();
+    }
+    loadState() {
+        try {
+            if (existsSync(this.statePath)) {
+                const data = JSON.parse(readFileSync(this.statePath, 'utf8'));
+                // restore persistent fields only (not runtime state like isRunning/pid)
+                this.state.totalEarnings = data.totalEarnings || 0;
+                this.state.jobsCompleted = data.jobsCompleted || 0;
+                this.state.jobsFailed = data.jobsFailed || 0;
+                this.state.activeDeployments = data.activeDeployments || [];
+            }
+        }
+        catch (err) {
+            // ignore load errors, start fresh
+        }
+    }
+    saveState() {
+        // debounce saves to avoid excessive disk writes
+        if (this.saveTimeout) {
+            clearTimeout(this.saveTimeout);
+        }
+        this.saveTimeout = setTimeout(() => {
+            try {
+                writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+            }
+            catch (err) {
+                // ignore save errors
+            }
+        }, 1000);
+    }
+    // force immediate save (for shutdown)
+    saveNow() {
+        if (this.saveTimeout) {
+            clearTimeout(this.saveTimeout);
+            this.saveTimeout = null;
+        }
+        try {
+            writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+        }
+        catch (err) {
+            // ignore
+        }
+    }
+    setRunning(pid) {
+        this.state.isRunning = true;
+        this.state.pid = pid;
+        this.state.startTime = Date.now();
+        this.saveState();
+    }
+    setStopped() {
+        this.state.isRunning = false;
+        this.state.pid = undefined;
+        this.saveNow();
+    }
+    addEarnings(amount) {
+        this.state.totalEarnings += amount;
+        this.saveState();
+    }
+    incrementCompleted() {
+        this.state.jobsCompleted++;
+        this.saveState();
+    }
+    incrementFailed() {
+        this.state.jobsFailed++;
+        this.saveState();
+    }
+    addDeployment(deploymentId) {
+        if (!this.state.activeDeployments.includes(deploymentId)) {
+            this.state.activeDeployments.push(deploymentId);
+            this.saveState();
+        }
+    }
+    removeDeployment(deploymentId) {
+        this.state.activeDeployments = this.state.activeDeployments.filter(id => id !== deploymentId);
+        this.saveState();
+    }
+    getActiveDeployments() {
+        return [...this.state.activeDeployments];
+    }
+    getState() {
+        return { ...this.state };
+    }
+    getUptime() {
+        if (!this.state.startTime)
+            return 0;
+        return Date.now() - this.state.startTime;
+    }
+}
+export const stateManager = new StateManager();

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+// shared types between all components
+export {};

package/dist/lib/usage-meter.js

@@ -0,0 +1,63 @@
+import Decimal from 'decimal.js';
+export class UsageMeter {
+    records = new Map();
+    // track usage for a running job
+    startMeter(jobId, nodeId, userId) {
+        this.records.set(jobId, {
+            jobId,
+            nodeId,
+            userId,
+            startTime: new Date(),
+            endTime: new Date(), // will update
+            usage: {
+                cpuSeconds: 0,
+                memoryGBSeconds: 0,
+                storageGBHours: 0,
+                networkGBTransferred: 0
+            },
+            cost: new Decimal(0)
+        });
+    }
+    // update usage metrics
+    updateUsage(jobId, metrics) {
+        const record = this.records.get(jobId);
+        if (!record)
+            return;
+        const now = new Date();
+        const elapsed = (now.getTime() - record.endTime.getTime()) / 1000; // seconds
+        // accumulate usage
+        record.usage.cpuSeconds += metrics.cpu * elapsed;
+        record.usage.memoryGBSeconds += metrics.memory * elapsed;
+        if (metrics.storage) {
+            record.usage.storageGBHours += metrics.storage * (elapsed / 3600);
+        }
+        if (metrics.network) {
+            const transferred = (metrics.network.rx + metrics.network.tx) / (1024 ** 3); // to gb
+            record.usage.networkGBTransferred += transferred;
+        }
+        record.endTime = now;
+    }
+    // finalize and calculate total cost
+    finalizeMeter(jobId, pricing) {
+        const record = this.records.get(jobId);
+        if (!record)
+            return null;
+        // convert to hours for pricing
+        const cpuHours = record.usage.cpuSeconds / 3600;
+        const memoryGBHours = record.usage.memoryGBSeconds / 3600;
+        // calculate costs
+        const cpuCost = new Decimal(cpuHours).times(pricing.cpuPerHour);
+        const memoryCost = new Decimal(memoryGBHours).times(pricing.memoryPerGBHour);
+        const storageCost = new Decimal(record.usage.storageGBHours).times(pricing.storagePerGBHour);
+        const networkCost = new Decimal(record.usage.networkGBTransferred).times(pricing.networkPerGB);
+        record.cost = cpuCost.plus(memoryCost).plus(storageCost).plus(networkCost);
+        // minimum charge 1 cent
+        if (record.cost.lessThan(0.01)) {
+            record.cost = new Decimal(0.01);
+        }
+        return record;
+    }
+    getRecord(jobId) {
+        return this.records.get(jobId);
+    }
+}