@nosana/node 1.0.0-rc

package/dist/NodeManager/monitoring/log/console/ConsoleLogger.d.ts

@@ -0,0 +1,20 @@
+import { Ora } from 'ora';
+import { LogObserver, NodeLogEntry } from '../NodeLog.js';
+export declare const consoleLogging: () => ConsoleLogger;
+export declare class ConsoleLogger implements LogObserver {
+    isNode: boolean;
+    private pending;
+    private expecting;
+    private progressBar;
+    private layerIds;
+    private multiProgressBar;
+    private kill;
+    private benchmarking;
+    private taskManagerActive;
+    private running;
+    spinner: Ora;
+    constructor(isNode?: boolean);
+    addObserver(): void;
+    isNodeObserver(): boolean;
+    update(log: NodeLogEntry, isNode?: boolean): void;
+}

package/dist/NodeManager/monitoring/log/console/ConsoleLogger.js

@@ -0,0 +1,290 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { MultiBar, Presets, SingleBar } from 'cli-progress';
+import { log } from '../NodeLog.js';
+import { convertFromBytes } from '../../../utils/convertFromBytes.js';
+export const consoleLogging = (() => {
+    let instance = null;
+    return () => {
+        if (!instance) {
+            instance = new ConsoleLogger();
+            instance.addObserver();
+        }
+        return instance;
+    };
+})();
+export class ConsoleLogger {
+    constructor(isNode = true) {
+        this.isNode = isNode;
+        this.pending = false;
+        this.kill = false;
+        this.benchmarking = false;
+        this.taskManagerActive = false;
+        this.running = false;
+    }
+    addObserver() {
+        log().addObserver(this);
+    }
+    isNodeObserver() {
+        return this.isNode;
+    }
+    update(log, isNode = true) {
+        if (!this.kill && log.type == 'kill-process') {
+            if (this.pending) {
+                this.spinner.stop();
+            }
+            if (this.progressBar) {
+                this.progressBar.stop();
+            }
+            if (this.multiProgressBar) {
+                this.multiProgressBar.stop();
+            }
+            this.kill = true;
+            this.pending = true;
+            this.expecting = log.pending?.expecting;
+            if (isNode && this.taskManagerActive) {
+                this.spinner.succeed(chalk.magenta(`${chalk.bgMagenta.bold(' TASKMANAGER ')} Exited`));
+            }
+            this.spinner = ora(log.log).start();
+        }
+        if (this.kill) {
+            if (log.type == 'kill-success') {
+                this.spinner.succeed(log.log);
+                this.kill = false;
+                this.pending = false;
+            }
+            else if (log.type == 'kill-error') {
+                this.spinner.fail(log.log);
+                this.kill = false;
+                this.pending = false;
+            }
+            else {
+                return;
+            }
+            return;
+        }
+        if (isNode) {
+            // --- TaskManager quiet window ---
+            if (log.method === 'TaskManager.start' && log.type === 'process') {
+                // Stop anything currently animating
+                if (this.pending)
+                    this.spinner.stop();
+                if (this.progressBar)
+                    this.progressBar.stop();
+                if (this.multiProgressBar)
+                    this.multiProgressBar.stop();
+                this.taskManagerActive = true;
+                this.pending = true;
+                this.spinner = ora(chalk.magenta(`${chalk.bgMagenta.bold(' TASKMANAGER ')} Running ${log.job}...`)).start();
+                // Block everything else until we see TaskManager.stop
+                return;
+            }
+            // While TaskManager is active, swallow all logs except the stop signal
+            if (this.taskManagerActive) {
+                if (log.method === 'TaskManager.start') {
+                    this.spinner.succeed(chalk.magenta(`${chalk.bgMagenta.bold(' TASKMANAGER ')} Ending ${log.job}...`));
+                    this.taskManagerActive = false;
+                    this.pending = false;
+                    return;
+                }
+                // Still inside TaskManager window: block other logs
+                return;
+            }
+        }
+        if (!this.benchmarking &&
+            log.method == 'BasicNode.specs' &&
+            log.type == 'process') {
+            this.benchmarking = true;
+            this.pending = true;
+            this.spinner = ora(chalk.green(`${chalk.bgGreen.bold(' Checking Specs ')}`)).start();
+            return;
+        }
+        if (this.benchmarking) {
+            // this.spinner.text =
+            //   chalk.cyan(`${this.spinner.text}\n`) + chalk.cyan(` \t➡️  ${log.log}`);
+        }
+        if (this.benchmarking && log.method == 'BasicNode.specs') {
+            this.benchmarking = false;
+            this.pending = false;
+            if (log.type == 'success') {
+                this.spinner.succeed(log.log);
+            }
+            else if (log.type == 'error') {
+                this.spinner.fail(log.log);
+            }
+            return;
+        }
+        else if (this.benchmarking) {
+            return;
+        }
+        // if (log.job && isNode) {
+        //   if (this.pending) {
+        //     this.spinner.stop();
+        //   }
+        //   this.spinner = ora(
+        //     chalk.green(
+        //       `${chalk.bgGreen.bold(' RUNNING ')} job ${chalk.bold(log.job)}`,
+        //     ),
+        //   ).start();
+        //   return;
+        // }
+        if (log.type == 'log') {
+            if (!isNode) {
+                process.stdout.write(log.log);
+            }
+            return;
+        }
+        if (log.type == 'process-bar-start') {
+            if (this.pending) {
+                this.spinner.stop();
+            }
+            if (this.progressBar) {
+                this.progressBar.stop();
+            }
+            this.progressBar = new SingleBar({
+                ...log.payload?.optProgressBar,
+                clearOnComplete: true,
+            }, log.payload.progressBarPreset);
+            this.progressBar.start(log.payload?.total, log.payload?.startValue, log.payload?.payload);
+            return;
+        }
+        if (log.type == 'process-bar-update') {
+            this.progressBar?.update(log.payload?.current, log.payload?.payload);
+            return;
+        }
+        if (log.type == 'process-bar-stop') {
+            this.progressBar?.stop();
+            this.progressBar = undefined;
+            return;
+        }
+        if (log.type == 'multi-process-bar-start') {
+            if (this.pending) {
+                this.spinner.stop();
+            }
+            if (this.multiProgressBar) {
+                this.multiProgressBar.stop();
+            }
+            if (!this.layerIds) {
+                this.layerIds = new Map();
+            }
+            this.multiProgressBar = new MultiBar({
+                fps: 200,
+                clearOnComplete: true,
+                hideCursor: true,
+                ...log.payload?.optProgressBar,
+            }, Presets.shades_grey);
+            return;
+        }
+        if (log.type == 'multi-process-bar-update') {
+            const { id, status, progressDetail } = log.payload?.event;
+            if (status === 'Pulling fs layer')
+                return;
+            let progressBar = this.layerIds?.get(id);
+            if (status === 'Downloading') {
+                const { current, total } = progressDetail;
+                const { format, value: totalValue } = convertFromBytes(total);
+                const { value } = convertFromBytes(current, format);
+                if (!progressBar) {
+                    progressBar = this.multiProgressBar?.create(totalValue, value, {
+                        status,
+                        layerId: id,
+                        format,
+                    });
+                    this.layerIds?.set(id, progressBar);
+                }
+                progressBar?.update(value, { status });
+                return;
+            }
+            if (status === 'Download complete' || status === 'Already exists') {
+                let progressBar = this.layerIds?.get(id);
+                if (!progressBar) {
+                    progressBar = this.multiProgressBar?.create(100, 100, {
+                        status,
+                        layerId: id,
+                        format: 'kb',
+                    });
+                }
+                progressBar?.update(progressBar?.getTotal(), { status });
+            }
+            if (progressBar) {
+                progressBar.update(progressBar.getTotal(), { status });
+            }
+            return;
+        }
+        if (log.type == 'multi-process-bar-stop') {
+            this.multiProgressBar?.stop();
+            this.multiProgressBar = undefined;
+            this.layerIds = undefined;
+            return;
+        }
+        if (this.pending) {
+            if (log.type == 'update') {
+                this.spinner.text = log.log;
+                return;
+            }
+            if (log.type == 'add') {
+                console.log(log.log);
+                return;
+            }
+            if (log.type == 'error' ||
+                log.method == this.expecting ||
+                log.type == 'stop') {
+                if (log.type == 'error' && log.method !== this.expecting) {
+                    this.spinner.stop();
+                    this.pending = false;
+                }
+                if (log.type == 'stop') {
+                    this.spinner.stop();
+                    if (log.log == '') {
+                        return;
+                    }
+                    else {
+                        console.log(log.log);
+                    }
+                    this.pending = false;
+                }
+                else {
+                    if (log.type == 'success') {
+                        if (this.spinner.text.includes('\n')) {
+                            // Split the text by the first newline and keep the part after it
+                            const [, rest] = this.spinner.text.split(/\n(.+)/); // Match the first occurrence and keep the rest
+                            // Update the spinner text by replacing the part before the first newline
+                            this.spinner.succeed(`${log.log}\n${rest}`);
+                        }
+                        else {
+                            this.spinner.succeed(log.log);
+                        }
+                    }
+                    else if (log.type == 'error' || log.type == 'kill-error') {
+                        if (this.spinner.text.includes('\n')) {
+                            const [, rest] = this.spinner.text.split(/\n(.+)/);
+                            this.spinner.fail(`${log.log}\n${rest}`);
+                        }
+                        else {
+                            this.spinner.fail(log.log);
+                        }
+                    }
+                    this.pending = false;
+                }
+            }
+        }
+        else {
+            if (log.pending?.isPending) {
+                this.pending = true;
+                this.expecting = log.pending?.expecting;
+                this.spinner = ora(log.log).start();
+            }
+            else {
+                console.log(log.log);
+            }
+        }
+        if (log.method == 'BasicNode.restartDelay' && log.type == 'success') {
+            this.expecting = undefined;
+            this.kill = false;
+            this.benchmarking = false;
+            this.running = false;
+            this.taskManagerActive = false;
+            this.spinner.stop();
+        }
+    }
+}

package/dist/NodeManager/monitoring/ping/PingHandler.d.ts

@@ -0,0 +1,13 @@
+export declare const ping: () => Promise<PingHandler>;
+export declare class PingHandler {
+    private timeoutId;
+    private intervalSeconds;
+    private sdk;
+    private address;
+    constructor();
+    start(): Promise<void>;
+    private scheduleNextPing;
+    private ping;
+    private getAuthSignature;
+    stop(): void;
+}

package/dist/NodeManager/monitoring/ping/PingHandler.js

@@ -0,0 +1,68 @@
+import { getSDK } from '../../sdk/index.js';
+import { configs } from '../../configs/configs.js';
+export const ping = (() => {
+    let instance = null;
+    return async () => {
+        if (!instance) {
+            instance = new PingHandler();
+        }
+        await instance.start();
+        return instance;
+    };
+})();
+export class PingHandler {
+    constructor() {
+        this.timeoutId = null;
+        this.intervalSeconds = 30;
+        this.sdk = getSDK();
+        this.address = this.sdk.solana.provider.wallet.publicKey;
+    }
+    async start() {
+        if (this.timeoutId)
+            return;
+        // start with an immediate ping
+        await this.scheduleNextPing(Date.now());
+    }
+    async scheduleNextPing(expectedTime) {
+        await this.ping();
+        const nextExpected = expectedTime + this.intervalSeconds * 1000;
+        const delay = Math.max(nextExpected - Date.now(), 0);
+        this.timeoutId = setTimeout(() => {
+            this.scheduleNextPing(nextExpected);
+        }, delay);
+    }
+    async ping() {
+        try {
+            const response = await fetch(`${configs().backendUrl}/nodes/heartbeat`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `${this.address}:${await this.getAuthSignature()}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ ping: 'pong' }),
+            });
+            if (response.ok) {
+                const json = await response.json();
+                if (json.maxHeartbeatsPerDay) {
+                    const newInterval = Math.floor((24 * 60 * 60) / json.maxHeartbeatsPerDay);
+                    if (newInterval !== this.intervalSeconds) {
+                        this.intervalSeconds = newInterval;
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('Ping failed:', err);
+        }
+    }
+    async getAuthSignature() {
+        const signature = (await this.sdk.solana.signMessage(configs().signMessage));
+        return Buffer.from(signature).toString('base64');
+    }
+    stop() {
+        if (this.timeoutId) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+    }
+}

package/dist/NodeManager/monitoring/proxy/loggingProxy.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+export declare const logEmitter: EventEmitter<[never]>;
+export interface LogEntry {
+    class: string;
+    method: string;
+    arguments: any[];
+    timestamp: string;
+    type: 'call' | 'return' | 'error';
+    result?: any;
+    error?: any;
+}
+export declare function applyLoggingProxyToClass(instance: any): void;
+export declare function createLoggingProxy<T extends object>(target: T): T;
+export declare function createFunctionLoggingProxy<T extends (...args: any[]) => any>(func: T, classLabel?: string): T;

package/dist/NodeManager/monitoring/proxy/loggingProxy.js

@@ -0,0 +1,145 @@
+import { EventEmitter } from 'events';
+export const logEmitter = new EventEmitter();
+export function applyLoggingProxyToClass(instance) {
+    const properties = [
+        'PodmanContainerOrchestration',
+        'DockerContainerOrchestration',
+        'containerOrchestration',
+        'resourceManager',
+        'provider',
+        'marketHandler',
+        'runHandler',
+        'jobHandler',
+        'flowHandler',
+        'apiHandler',
+        'repository',
+        'jobExternalUtil',
+        'healthHandler',
+        'stakeHandler',
+        'expiryHandler',
+        'specsHandler',
+        'progressBarReporter',
+        'registerHandler',
+    ];
+    properties.forEach((property) => {
+        if (instance.hasOwnProperty(property)) {
+            const value = instance[property];
+            instance[property] = createLoggingProxy(value);
+        }
+    });
+}
+export function createLoggingProxy(target) {
+    const className = Object.getPrototypeOf(target).constructor.name;
+    const formatArguments = (args) => {
+        return args.map((arg) => {
+            if (typeof arg === 'function') {
+                return arg.constructor.name === 'AsyncFunction'
+                    ? '[AsyncFunction]'
+                    : '[Function]';
+            }
+            return arg;
+        });
+    };
+    return new Proxy(target, {
+        get(target, propKey, receiver) {
+            const originalMethod = target[propKey];
+            if (typeof originalMethod === 'function') {
+                return (...args) => {
+                    const logEntry = {
+                        class: className,
+                        method: String(propKey),
+                        arguments: formatArguments(args),
+                        timestamp: new Date().toISOString(),
+                        type: 'call',
+                    };
+                    logEmitter.emit('log', logEntry);
+                    try {
+                        // Check if the method is async (returns a Promise)
+                        const result = originalMethod.apply(target, args);
+                        if (result instanceof Promise) {
+                            return result
+                                .then((resolvedValue) => {
+                                logEntry.type = 'return';
+                                logEntry.result = resolvedValue;
+                                logEmitter.emit('log', logEntry);
+                                return resolvedValue;
+                            })
+                                .catch((error) => {
+                                logEntry.type = 'error';
+                                logEntry.error = error;
+                                logEmitter.emit('log', logEntry);
+                                throw error;
+                            });
+                        }
+                        else {
+                            // If it's a synchronous function, log and return the result immediately
+                            logEntry.type = 'return';
+                            logEntry.result = result;
+                            logEmitter.emit('log', logEntry);
+                            return result;
+                        }
+                    }
+                    catch (error) {
+                        logEntry.type = 'error';
+                        logEntry.error = error;
+                        logEmitter.emit('log', logEntry);
+                        throw error;
+                    }
+                };
+            }
+            return Reflect.get(target, propKey, receiver);
+        },
+    });
+}
+export function createFunctionLoggingProxy(func, classLabel = 'StandaloneFunction') {
+    const formatArguments = (args) => {
+        return args.map((arg) => {
+            if (typeof arg === 'function') {
+                return arg.constructor.name === 'AsyncFunction'
+                    ? '[AsyncFunction]'
+                    : '[Function]';
+            }
+            return arg;
+        });
+    };
+    return ((...args) => {
+        const logEntry = {
+            class: classLabel,
+            method: func.name || '[anonymous]',
+            arguments: formatArguments(args),
+            timestamp: new Date().toISOString(),
+            type: 'call',
+        };
+        logEmitter.emit('log', logEntry);
+        try {
+            const result = func(...args);
+            if (result instanceof Promise) {
+                return result
+                    .then((resolvedValue) => {
+                    logEntry.type = 'return';
+                    logEntry.result = resolvedValue;
+                    logEmitter.emit('log', logEntry);
+                    return resolvedValue;
+                })
+                    .catch((error) => {
+                    logEntry.type = 'error';
+                    logEntry.error = error;
+                    logEmitter.emit('log', logEntry);
+                    throw error;
+                });
+            }
+            else {
+                logEntry.type = 'return';
+                logEntry.result = result;
+                logEmitter.emit('log', logEntry);
+                return result;
+            }
+        }
+        catch (error) {
+            logEntry.type = 'error';
+            logEntry.error = error;
+            logEmitter.emit('log', logEntry);
+            throw error;
+        }
+    });
+}

package/dist/NodeManager/monitoring/state/NodeState.d.ts

@@ -0,0 +1,29 @@
+import { LogEntry } from '../proxy/loggingProxy.js';
+export interface StateObserver {
+    update(status: string, state: {
+        [key: string]: string;
+    }, timestamp: number): void;
+}
+export declare const state: (node: string) => NodeState;
+export declare class NodeState {
+    shared: {
+        [key: string]: string;
+    };
+    private info;
+    private status;
+    private state;
+    private history;
+    private observers;
+    constructor(node: string);
+    clear(): void;
+    getNodeInfo(): {
+        state: import("./classifyState.js").StateCategory;
+    };
+    addObserver(observer: StateObserver): void;
+    removeObserver(observer: StateObserver): void;
+    private notifyObservers;
+    addState(status: string, state: {
+        [key: string]: string;
+    }): void;
+    process(data: LogEntry): void;
+}