kova-node-cli 0.1.0

package/dist/commands/start.js

@@ -0,0 +1,358 @@
+import { logger } from '../lib/logger.js';
+import { P2PNode } from '../lib/p2p.js';
+import { DockerManager } from '../lib/docker.js';
+import { ResourceMonitor } from '../lib/monitor.js';
+import { NodeConfig } from '../lib/config.js';
+import { ContainerManager } from '../services/container-manager.js';
+import { JobHandler } from '../services/job-handler.js';
+import { HeartbeatService } from '../services/heartbeat.js';
+import { NodeAPIServer } from '../api/server.js';
+import { stateManager } from '../lib/state.js';
+import { ResourceLimitManager } from '../lib/resource-limits.js';
+import { AutoBidder } from '../services/auto-bidder.js';
+import { LeaseHandler } from '../services/lease-handler.js';
+import { DeploymentExecutor } from '../services/deployment-executor.js';
+import { randomBytes } from 'crypto';
+async function registerWithOrchestrator(nodeId, resources, apiKey, walletAddress, orchestratorUrl, maxRetries = 5) {
+    if (!orchestratorUrl) {
+        logger.warn('no orchestrator URL configured, skipping HTTP registration');
+        return null;
+    }
+    const body = {
+        nodeId,
+        resources,
+        timestamp: Date.now(),
+        version: '0.0.1'
+    };
+    // prefer api key over wallet
+    if (apiKey) {
+        body.apiKey = apiKey;
+    }
+    else if (walletAddress) {
+        body.walletAddress = walletAddress;
+    }
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            const response = await fetch(`${orchestratorUrl}/api/v1/nodes/register`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body)
+            });
+            if (response.ok) {
+                const data = await response.json();
+                logger.info({
+                    orchestratorUrl,
+                    walletAddress: data.walletAddress,
+                    providerId: data.providerId
+                }, 'registered with orchestrator');
+                return {
+                    providerId: data.providerId,
+                    walletAddress: data.walletAddress
+                };
+            }
+            else {
+                logger.warn({ status: response.status, attempt }, 'failed to register with orchestrator');
+            }
+        }
+        catch (err) {
+            logger.warn({ err, attempt, maxRetries }, 'could not reach orchestrator for HTTP registration');
+        }
+        if (attempt < maxRetries) {
+            const delay = Math.min(attempt * 3000, 15000);
+            logger.info({ attempt, nextRetryMs: delay }, 'retrying registration...');
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+    return null;
+}
+export async function startNode(options) {
+    logger.info('starting kova node...');
+    // check for authentication (api key or wallet)
+    const apiKey = options.apiKey || options.k;
+    const walletAddress = options.wallet || options.w;
+    if (!apiKey && !walletAddress) {
+        console.error('\n❌ ERROR: Either --api-key or --wallet is required');
+        console.error('\nRecommended: kova-node start --api-key YOUR_API_KEY');
+        console.error('Legacy: kova-node start --wallet YOUR_WALLET_ADDRESS');
+        console.error('\nGet your API key from https://test.kovanetwork.com/provider');
+        process.exit(1);
+    }
+    // validate wallet address format if provided
+    if (walletAddress && !/^0x[a-fA-F0-9]{40}$/.test(walletAddress)) {
+        console.error('\n❌ ERROR: Invalid wallet address format');
+        console.error('Wallet address must be a valid Ethereum address (0x followed by 40 hex characters)');
+        console.error(`Provided: ${walletAddress}`);
+        process.exit(1);
+    }
+    // validate api key format if provided
+    if (apiKey && !apiKey.startsWith('sk_live_')) {
+        console.error('\n❌ ERROR: Invalid API key format');
+        console.error('API key must start with sk_live_');
+        console.error(`Provided: ${apiKey.substring(0, 15)}...`);
+        process.exit(1);
+    }
+    // mark as running
+    stateManager.setRunning(process.pid);
+    // load config or use defaults
+    const config = await NodeConfig.load(options.config);
+    // setup resource limits based on CLI args
+    const limitManager = await ResourceLimitManager.createFromOptions({
+        maxCpu: options.maxCpu,
+        maxMemory: options.maxMemory,
+        maxDisk: options.maxDisk
+    });
+    // check if docker is even running
+    const docker = new DockerManager();
+    const dockerReady = await docker.checkDocker();
+    if (!dockerReady) {
+        logger.error('docker not running... install docker first');
+        process.exit(1);
+    }
+    // start monitoring resources
+    const monitor = new ResourceMonitor();
+    await monitor.start();
+    // join the p2p network
+    const p2p = new P2PNode({
+        port: parseInt(options.port) || 4001,
+        bootstrapNodes: config.bootstrapNodes
+    });
+    try {
+        await p2p.start();
+        const nodeId = p2p.getPeerId();
+        logger.info({ nodeId, walletAddress }, 'connected to kova network');
+        // get system resources but use provider limits
+        const systemResources = await monitor.getAvailableResources();
+        const providerLimits = limitManager.getLimits();
+        // advertise provider limits, not full system resources
+        const advertisedResources = {
+            cpu: {
+                cores: providerLimits.cpu,
+                available: providerLimits.cpu
+            },
+            memory: {
+                total: providerLimits.memory,
+                available: providerLimits.memory
+            },
+            disk: systemResources.disk,
+            network: systemResources.network,
+            gpu: systemResources.gpu || []
+        };
+        await p2p.advertiseCapabilities(advertisedResources);
+        // register with orchestrator via HTTP
+        const registrationResult = await registerWithOrchestrator(nodeId, advertisedResources, apiKey, walletAddress, config.orchestratorUrl);
+        const registered = !!registrationResult;
+        const effectiveWallet = registrationResult?.walletAddress || walletAddress;
+        if (registered) {
+            console.log('\n========================================');
+            console.log('✓ KOVA NODE STARTED SUCCESSFULLY');
+            console.log('========================================');
+            console.log(`Node ID: ${nodeId}`);
+            console.log(`Wallet: ${effectiveWallet}`);
+            console.log(`\nAllocated Resources:`);
+            console.log(`CPU: ${providerLimits.cpu} cores`);
+            console.log(`Memory: ${providerLimits.memory} GB`);
+            console.log(`Disk: ${providerLimits.disk} GB`);
+            console.log(`\nDashboard: https://test.kovanetwork.com`);
+            console.log('Connect with your wallet to view earnings');
+            console.log('========================================\n');
+        }
+        else {
+            console.log('\n⚠️  Node started but registration failed');
+            console.log('Check orchestrator connection and try again\n');
+        }
+        // generate access token for orchestrator → provider shell proxy auth
+        const accessToken = randomBytes(32).toString('hex');
+        const apiPort = config.apiPort || 4002;
+        // start heartbeat service to keep orchestrator updated
+        let heartbeat = null;
+        if (config.orchestratorUrl) {
+            heartbeat = new HeartbeatService(nodeId, config.orchestratorUrl, monitor, limitManager, 60, apiPort, accessToken);
+            await heartbeat.start();
+            logger.info('heartbeat service started - sending status every 60 seconds');
+        }
+        else {
+            logger.warn('no orchestrator URL configured - heartbeat disabled');
+        }
+        // setup job handling
+        const containerMgr = new ContainerManager();
+        await containerMgr.start();
+        const jobHandler = new JobHandler(p2p, containerMgr, limitManager, config.orchestratorUrl);
+        // initialize deployment executor whenever orchestrator is configured
+        // shell sessions and stats only need local docker access, not registration
+        let deploymentExecutor = null;
+        if (config.orchestratorUrl) {
+            deploymentExecutor = new DeploymentExecutor({
+                orchestratorUrl: config.orchestratorUrl,
+                apiKey
+            });
+            // discover any existing deployments from previous runs
+            await deploymentExecutor.discoverExistingDeployments();
+            logger.info('deployment executor initialized');
+        }
+        // start api server for exec/logs (with deployment executor if available)
+        const apiServer = new NodeAPIServer(containerMgr, deploymentExecutor || undefined, apiPort, accessToken);
+        await apiServer.start();
+        // listen for pending jobs from heartbeat
+        const processedJobs = new Set();
+        if (heartbeat) {
+            heartbeat.on('pending-jobs', (jobs) => {
+                logger.info({ count: jobs.length }, 'processing pending jobs from heartbeat');
+                for (const job of jobs) {
+                    // skip if already processed
+                    if (processedJobs.has(job.id)) {
+                        continue;
+                    }
+                    processedJobs.add(job.id);
+                    jobHandler.handleJob(job).catch(err => {
+                        logger.error({ err, jobId: job.id }, 'failed to handle job from heartbeat');
+                    });
+                }
+            });
+            // evict old entries instead of clearing everything
+            setInterval(() => {
+                // keep the set from growing unbounded but don't clear it wholesale
+                // which could cause duplicate processing
+                if (processedJobs.size > 10000) {
+                    const entries = Array.from(processedJobs);
+                    const toRemove = entries.slice(0, entries.length - 5000);
+                    for (const id of toRemove) {
+                        processedJobs.delete(id);
+                    }
+                }
+            }, 5 * 60 * 1000);
+        }
+        // wire up earnings tracking
+        jobHandler.on('job-completed', ({ jobId, earnings }) => {
+            logger.info({ jobId, earnings }, 'earned from job');
+            stateManager.addEarnings(earnings);
+            stateManager.incrementCompleted();
+        });
+        jobHandler.on('job-failed', ({ jobId }) => {
+            logger.warn({ jobId }, 'job failed');
+            stateManager.incrementFailed();
+        });
+        // listen for jobs
+        p2p.on('job-request', async (job) => {
+            // only log non-sensitive job info (NOT env vars)
+            logger.info({
+                jobId: job.id,
+                image: job.image,
+                resources: job.resources
+                // intentionally NOT logging: env, userId (privacy)
+            }, 'got a job request');
+            const accepted = await jobHandler.handleJob(job);
+            if (accepted) {
+                logger.info({ jobId: job.id }, 'job accepted and running');
+            }
+        });
+        // new deployment system
+        let autoBidder = null;
+        let leaseHandler = null;
+        if (config.orchestratorUrl && registered && registrationResult) {
+            // use provider id from registration
+            const providerId = registrationResult.providerId;
+            // verify provider account is registered
+            try {
+                const providerRes = await fetch(`${config.orchestratorUrl}/api/v1/provider/status`, {
+                    headers: {
+                        'Authorization': `Bearer ${apiKey}`
+                    }
+                });
+                if (providerRes.ok) {
+                    logger.info({ providerId }, 'provider account ready');
+                }
+            }
+            catch (err) {
+                logger.warn('failed to verify provider account');
+            }
+            // deployment executor already initialized above
+            // setup auto-bidder for competitive bidding
+            autoBidder = new AutoBidder({
+                nodeId,
+                providerId,
+                orchestratorUrl: config.orchestratorUrl,
+                apiKey, // pass the api key for authentication
+                pricingStrategy: {
+                    cpuPricePerCore: 0.00017, // ~$0.01 per core per hour
+                    memoryPricePerGb: 0.00008, // ~$0.005 per GB per hour
+                    gpuPricePerUnit: 0.01, // ~$0.60 per gpu per hour
+                    margin: 0.9 // bid 10% below cost to win
+                }
+            }, monitor);
+            autoBidder.start(15000); // check for orders every 15s
+            logger.info({ nodeId }, 'auto-bidder started - will bid on suitable orders');
+            // setup lease handler
+            if (!deploymentExecutor) {
+                throw new Error('deployment executor not initialized');
+            }
+            leaseHandler = new LeaseHandler({
+                nodeId,
+                providerId,
+                orchestratorUrl: config.orchestratorUrl,
+                apiKey
+            }, deploymentExecutor);
+            leaseHandler.start(10000); // check for leases every 10s
+            logger.info({ nodeId }, 'lease handler started - will execute assigned deployments');
+            // wire up shell session handling from p2p to deployment executor
+            p2p.on('shell-start', async (data) => {
+                const { sessionId, deploymentId, serviceName } = data;
+                logger.info({ sessionId, deploymentId, serviceName }, 'shell-start request received');
+                const success = await deploymentExecutor.startShellSession(sessionId, deploymentId, serviceName, (output) => {
+                    // send output back to orchestrator via p2p
+                    p2p.sendToOrchestrator({
+                        type: 'shell-output',
+                        data: { sessionId, output }
+                    });
+                });
+                if (!success) {
+                    logger.warn({ sessionId, deploymentId }, 'failed to start shell session');
+                }
+            });
+            p2p.on('shell-input', (data) => {
+                const { sessionId, input } = data;
+                deploymentExecutor.sendShellInput(sessionId, input);
+            });
+            p2p.on('shell-resize', (data) => {
+                const { sessionId, cols, rows } = data;
+                deploymentExecutor.resizeShell(sessionId, cols, rows);
+            });
+            p2p.on('shell-close', (data) => {
+                const { sessionId } = data;
+                deploymentExecutor.closeShellSession(sessionId);
+            });
+            // forward shell-closed events from executor back to orchestrator
+            deploymentExecutor.on('shell-closed', ({ sessionId }) => {
+                p2p.sendToOrchestrator({
+                    type: 'shell-closed',
+                    data: { sessionId }
+                });
+            });
+            logger.info('shell session handlers configured');
+        }
+        // graceful shutdown on both SIGINT and SIGTERM
+        const shutdown = async (signal) => {
+            logger.info({ signal }, 'shutting down...');
+            stateManager.setStopped();
+            if (autoBidder) {
+                autoBidder.stop();
+            }
+            if (leaseHandler) {
+                leaseHandler.stop();
+            }
+            if (heartbeat) {
+                await heartbeat.stop();
+            }
+            await apiServer.stop();
+            await containerMgr.stop();
+            await p2p.stop();
+            await monitor.stop();
+            process.exit(0);
+        };
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+    }
+    catch (err) {
+        logger.error({ err }, 'failed to start');
+        process.exit(1);
+    }
+}

package/dist/commands/status.js

@@ -0,0 +1,50 @@
+import { logger } from '../lib/logger.js';
+import { ResourceMonitor } from '../lib/monitor.js';
+import { stateManager } from '../lib/state.js';
+export async function statusCommand() {
+    try {
+        const state = stateManager.getState();
+        const monitor = new ResourceMonitor();
+        await monitor.start();
+        const resources = await monitor.getAvailableResources();
+        console.log('\n📊 kova node status\n');
+        // node running status
+        if (state.isRunning) {
+            const uptime = stateManager.getUptime();
+            const hours = Math.floor(uptime / 1000 / 60 / 60);
+            const minutes = Math.floor((uptime / 1000 / 60) % 60);
+            console.log(`node status: 🟢 online (${hours}h ${minutes}m uptime)`);
+            console.log(`pid: ${state.pid}`);
+        }
+        else {
+            console.log('node status: 🔴 offline');
+        }
+        console.log('');
+        // resources
+        console.log(`cpu: ${resources.cpu.available.toFixed(1)} / ${resources.cpu.cores} cores available`);
+        console.log(`memory: ${resources.memory.available} / ${resources.memory.total} GB available`);
+        console.log(`network: ~${resources.network.bandwidth} Mbps`);
+        // check docker
+        const Docker = (await import('dockerode')).default;
+        const docker = new Docker();
+        try {
+            await docker.ping();
+            console.log('docker: ✅ running');
+        }
+        catch {
+            console.log('docker: ❌ not running');
+        }
+        // earnings summary
+        if (state.isRunning) {
+            console.log('');
+            console.log(`jobs completed: ${state.jobsCompleted}`);
+            console.log(`total earned: $${state.totalEarnings.toFixed(4)}`);
+        }
+        console.log('');
+        await monitor.stop();
+    }
+    catch (err) {
+        logger.error({ err }, 'status check failed');
+        process.exit(1);
+    }
+}

package/dist/commands/stop.js

@@ -0,0 +1,101 @@
+// stop command - gracefully stops a running kova node
+import { logger } from '../lib/logger.js';
+import { stateManager } from '../lib/state.js';
+// check if a process is running
+function isProcessRunning(pid) {
+    try {
+        // sending signal 0 doesn't actually send a signal, just checks if process exists
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // process doesn't exist or we don't have permission
+        return err.code === 'EPERM';
+    }
+}
+// wait for a process to terminate with timeout
+async function waitForProcessExit(pid, timeoutMs = 30000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        if (!isProcessRunning(pid)) {
+            return true;
+        }
+        await new Promise(resolve => setTimeout(resolve, 500));
+    }
+    return false;
+}
+export async function stopCommand() {
+    logger.info('stopping kova node...');
+    // check if node is running by reading state
+    const state = stateManager.getState();
+    if (!state.isRunning || !state.pid) {
+        console.log('\nkova node is not running');
+        return;
+    }
+    const pid = state.pid;
+    // verify the process is actually running
+    if (!isProcessRunning(pid)) {
+        console.log('\nkova node is not running (stale state)');
+        stateManager.setStopped();
+        return;
+    }
+    console.log(`\nfound kova node running with pid ${pid}`);
+    console.log('sending graceful shutdown signal...');
+    try {
+        // send SIGINT for graceful shutdown (same as ctrl+c)
+        process.kill(pid, 'SIGINT');
+        console.log('waiting for node to stop...');
+        // wait up to 30 seconds for graceful shutdown
+        const stopped = await waitForProcessExit(pid, 30000);
+        if (stopped) {
+            console.log('\n✓ kova node stopped successfully');
+            // show final stats
+            const finalState = stateManager.getState();
+            console.log(`\nfinal stats:`);
+            console.log(`  jobs completed: ${finalState.jobsCompleted}`);
+            console.log(`  jobs failed: ${finalState.jobsFailed}`);
+            console.log(`  total earnings: ${finalState.totalEarnings.toFixed(4)}`);
+            console.log(`  active deployments: ${finalState.activeDeployments.length}`);
+            if (finalState.activeDeployments.length > 0) {
+                console.log('\nwarning: there were active deployments when node stopped');
+                console.log('these will be picked up again when node restarts');
+            }
+        }
+        else {
+            // graceful shutdown timed out, try harder
+            console.log('\ngraceful shutdown timed out, forcing termination...');
+            try {
+                process.kill(pid, 'SIGTERM');
+                // wait another 10 seconds
+                const forceStopped = await waitForProcessExit(pid, 10000);
+                if (forceStopped) {
+                    console.log('✓ node terminated');
+                }
+                else {
+                    // last resort
+                    console.log('sending SIGKILL...');
+                    process.kill(pid, 'SIGKILL');
+                    await waitForProcessExit(pid, 5000);
+                    console.log('✓ node killed');
+                }
+            }
+            catch (err) {
+                console.error('failed to terminate process');
+            }
+            // update state regardless
+            stateManager.setStopped();
+        }
+    }
+    catch (err) {
+        if (err.code === 'ESRCH') {
+            console.log('\nkova node already stopped');
+            stateManager.setStopped();
+        }
+        else if (err.code === 'EPERM') {
+            console.error('\n❌ permission denied - try running with sudo');
+        }
+        else {
+            console.error(`\n❌ failed to stop node: ${err.message}`);
+        }
+    }
+}

package/dist/lib/client.js

@@ -0,0 +1,87 @@
+// shared cli helpers for api calls, auth, and output formatting
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const CONFIG_DIR = join(homedir(), '.kova');
+const AUTH_FILE = join(CONFIG_DIR, 'auth.json');
+export function getApiUrl() {
+    return process.env.KOVA_API_URL || 'https://app.kovanetwork.com';
+}
+export function getAuthToken() {
+    try {
+        if (!existsSync(AUTH_FILE))
+            return null;
+        const data = JSON.parse(readFileSync(AUTH_FILE, 'utf8'));
+        return data.token || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveAuthToken(token) {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(AUTH_FILE, JSON.stringify({ token, savedAt: new Date().toISOString() }));
+}
+export function clearAuthToken() {
+    try {
+        if (existsSync(AUTH_FILE)) {
+            writeFileSync(AUTH_FILE, '{}');
+        }
+    }
+    catch { }
+}
+export async function authFetch(path, options = {}) {
+    const token = getAuthToken();
+    const url = `${getApiUrl()}${path}`;
+    const headers = {
+        'Content-Type': 'application/json',
+        ...(options.headers || {})
+    };
+    if (token) {
+        headers['Authorization'] = `Bearer ${token}`;
+    }
+    return fetch(url, { ...options, headers });
+}
+export function formatDate(dateStr) {
+    try {
+        const d = new Date(dateStr);
+        return d.toLocaleString();
+    }
+    catch {
+        return dateStr;
+    }
+}
+export function formatTable(rows) {
+    if (rows.length === 0)
+        return;
+    const keys = Object.keys(rows[0]);
+    const widths = {};
+    // calculate column widths
+    for (const key of keys) {
+        widths[key] = key.length;
+        for (const row of rows) {
+            const val = String(row[key] ?? '');
+            widths[key] = Math.max(widths[key], val.length);
+        }
+    }
+    // print header
+    const header = keys.map(k => k.padEnd(widths[k])).join('  ');
+    console.log(header);
+    console.log(keys.map(k => '-'.repeat(widths[k])).join('  '));
+    // print rows
+    for (const row of rows) {
+        const line = keys.map(k => String(row[k] ?? '').padEnd(widths[k])).join('  ');
+        console.log(line);
+    }
+}
+export function handleApiError(err) {
+    if (err.cause?.code === 'ECONNREFUSED') {
+        console.error('\ncannot connect to kova api. check your network or KOVA_API_URL setting.');
+    }
+    else {
+        console.error(`\nerror: ${err.message || 'unknown error'}`);
+    }
+    process.exit(1);
+}