@nosana/node 1.0.0-rc

package/dist/NodeManager/node/stake/StakeHandler.js

@@ -0,0 +1,111 @@
+import chalk from 'chalk';
+import { SECONDS_PER_DAY, sleep } from '../../utils/utils.js';
+const NO_STAKE_AMOUNT = 0;
+export class StakeHandler {
+    constructor(sdk) {
+        this.sdk = sdk;
+        this.stake = {
+            amount: 0,
+            duration: 0,
+        };
+        this.address = this.sdk.solana.provider.wallet.publicKey;
+    }
+    async createAta() {
+        try {
+            await this.sdk.solana.createNosAta(this.address);
+        }
+        catch (error) {
+            throw new Error(`error creating NOS ATA: ${error}`);
+        }
+    }
+    async nodeHasStakingAccount() {
+        try {
+            const result = await this.sdk.stake.get(this.address);
+            this.stake = {
+                amount: result.amount,
+                duration: result.duration,
+            };
+            return true;
+        }
+        catch (error) {
+            if (error.message && error.message.includes('Account does not exist')) {
+                return false;
+            }
+            throw new Error(`error getting node staking account: ${error}`);
+        }
+    }
+    async createStakingAccount() {
+        try {
+            await this.sdk.stake.create(this.address, 0, 14);
+            await sleep(4);
+            const result = await this.sdk.stake.get(this.address);
+            this.stake = {
+                amount: result.amount,
+                duration: result.duration,
+            };
+            return true;
+        }
+        catch (error) {
+            throw new Error(`error creating or retriveing staking account: ${error}`);
+        }
+    }
+    async topUpStakingAccount(market) {
+        try {
+            const minStakeForMarket = Number(market?.nodeXnosMinimum) || 0;
+            const currentStake = Number(this.stake.amount || 0);
+            const diff = minStakeForMarket - currentStake;
+            await this.sdk.stake.topup(diff);
+            await sleep(4);
+            const result = await this.sdk.stake.get(this.address);
+            this.stake = {
+                amount: result.amount,
+                duration: result.duration,
+            };
+            if (Number(this.stake.amount || 0) >= minStakeForMarket) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        catch (error) {
+            throw new Error(`error creating or retriveing staking account: ${error}`);
+        }
+    }
+    async failTopUpStakingAccount() {
+        throw new Error(chalk.red(`Cannot enter Market, Insufficient Staked NOS for Market`));
+    }
+    getStakeAccount() {
+        return this.stake;
+    }
+    canProceedWithoutStake(market, nosBalance) {
+        const minStakeForMarket = Number(market?.nodeXnosMinimum) || 0;
+        const currentStake = Number(this.stake.amount || 0);
+        if (minStakeForMarket > NO_STAKE_AMOUNT &&
+            currentStake < market.nodeXnosMinimum) {
+            const diff = minStakeForMarket - currentStake;
+            if (!nosBalance ||
+                !nosBalance.uiAmount ||
+                Number(nosBalance.amount) < diff) {
+                return false;
+            }
+        }
+        return true;
+    }
+    getStakeActionInfotext(market) {
+        const minStakeForMarket = Number(market?.nodeXnosMinimum) || 0;
+        const currentStake = Number(this.stake.amount || 0);
+        let text = `Market requires a minimum of ${minStakeForMarket / 1e6} NOS to be staked.`;
+        if (currentStake > 0) {
+            text += ` You currently have ${chalk.bold(currentStake / 1e6)} NOS staked.`;
+        }
+        return text;
+    }
+    getStakeActionQuerytext(market) {
+        const minStakeForMarket = Number(market?.nodeXnosMinimum) || 0;
+        const currentStake = Number(this.stake.amount || 0);
+        const diff = minStakeForMarket - currentStake;
+        let text = chalk.yellow(`Do you want to top up your stake with ${chalk.bold(diff / 1e6)} NOS with unstake duration of ${chalk.bold(this.stake.duration / SECONDS_PER_DAY)} days? (Y/n):`);
+        return text;
+    }
+}

package/dist/NodeManager/node/task/TaskManager.d.ts

@@ -0,0 +1,267 @@
+/// <reference types="node" />
+import type WebSocket from 'ws';
+import EventEmitter from 'events';
+import { JobDefinition, Operation, OperationType } from '@nosana/sdk';
+import { NodeRepository } from '../../repository/NodeRepository.js';
+import { Provider } from '../../provider/Provider.js';
+import { Flow } from '@nosana/sdk';
+export type TaskManagerOps = Array<Operation<OperationType>>;
+export type ExecutionContext = {
+    group: string;
+    ops: string[];
+};
+export type DependencyContext = {
+    dependencies: string[];
+    dependents: string[];
+};
+export declare const StopReasons: {
+    readonly COMPLETED: "completed";
+    readonly EXPIRED: "expired";
+    readonly STOPPED: "stopped";
+    readonly QUIT: "quit";
+    readonly UNKNOWN: "unknown";
+    readonly RESTART: "restart";
+};
+export type StopReason = (typeof StopReasons)[keyof typeof StopReasons];
+export declare const Statuses: {
+    readonly SUCCESS: "success";
+    readonly STOPPED: "stopped";
+    readonly FAILED: "failed";
+};
+export declare const OperationProgressStatuses: {
+    readonly FINISHED: "finished";
+    readonly STOPPED: "stopped";
+    readonly FAILED: "failed";
+    readonly RUNNING: "running";
+    readonly RESTARTING: "restarting";
+    readonly STOPPING: "stopping";
+    readonly STARTING: "starting";
+    readonly WAITING: "waiting";
+    readonly PENDING: "pending";
+    readonly INIT: "init";
+};
+export type LogType = 'container' | 'info' | 'error';
+export interface TaskLog {
+    opId: string;
+    group: string;
+    type: LogType;
+    timestamp: number;
+    message: any;
+}
+export type OperationData = {
+    host?: string;
+    endpoint?: {
+        [key: string]: string;
+    };
+    deployment_endpoint?: string;
+    results?: Record<string, any>;
+};
+type InterpolateFn = <T>(value: T) => T;
+type InterpolateOpFn = <T extends OperationType>(op: Operation<T>) => Operation<T>;
+export type GlobalDataStore = Record<string, OperationData>;
+export type GlobalStore = {
+    job: string;
+    host: string;
+    project: string;
+    frps_address: string;
+    variables?: Record<string, string>;
+};
+export type Status = (typeof Statuses)[keyof typeof Statuses];
+export default class TaskManager {
+    protected provider: Provider;
+    protected repository: NodeRepository;
+    protected job: string;
+    protected project: string;
+    protected definition?: JobDefinition | undefined;
+    /**
+     * All operations defined in the Job Definition (JD).
+     */
+    protected operations: TaskManagerOps | undefined;
+    /**
+     * The ordered execution plan built from the job definition.
+     * Each item represents a group of ops that run together horizontally.
+     */
+    protected executionPlan: ExecutionContext[];
+    /**
+     * this creates a map to assign the dependency
+     */
+    protected dependecyMap: Map<string, DependencyContext>;
+    /**
+     * A map for fast lookup of operations by their ID.
+     * Useful during validation and execution.
+     */
+    protected opMap: Map<string, Operation<OperationType>>;
+    /**
+     * Global data store.
+     *
+     * This allows operations to reference data produced by others using literals like:
+     *   "%%global.frps_address%%"
+     *   "%%global.project%%"
+     *
+     * Supported keys:
+     * - frps_address: The current FRPS address.
+     * - project: The project public key of the jobs project.
+     */
+    protected globalStore: GlobalStore;
+    /**
+     * Global data store for all operations in a job definition.
+     *
+     * This allows operations to reference data produced by others using literals like:
+     *   "%%ops.nginx-1.results.someKey%%"
+     *   "%%ops.nginx-1.host%%"
+     *
+     * Supported keys:
+     * - result: Stores the output of an operation so it can be accessed later, even if it was unknown at the start of the job.
+     * - host: Stores the reachable host/URL of the operation. Since Docker container names are dynamic,
+     *         this ensures other operations can communicate with it without needing to know the name in advance.
+     */
+    protected globalOpStore: GlobalDataStore;
+    /**
+     * Main controller to allow global cancellation of the entire task flow.
+     * All per-op controllers should eventually be tied to this as their parent,
+     * or fallback to this if no specific controller is assigned yet.
+     */
+    protected mainAbortController: AbortController;
+    /**
+     * Stores one AbortController per op.
+     * Used to signal cancellation to all ops in a group or individually if needed.
+     */
+    protected abortControllerMap: Map<string, AbortController>;
+    /**
+     * Keeps track of the currently running group.
+     * Useful for coordinating group-level logic or logging.
+     */
+    protected currentGroup: string | undefined;
+    /**
+     * keeps track of all promises of the current running group
+     */
+    protected currentGroupOperationsPromises: Map<string, Promise<void>>;
+    /**
+     * this is to create concurrency control on the operations
+     */
+    protected lockedOperations: Map<string, string>;
+    /**
+     * this is used to track the operations statuses
+     */
+    protected operationStatus: Map<string, (typeof OperationProgressStatuses)[keyof typeof OperationProgressStatuses]>;
+    /**
+     * this is to track event emitter to emit events
+     */
+    protected operationsEventEmitters: Map<string, EventEmitter>;
+    /**
+     * save log buffer for streaming logs
+     */
+    protected opLogBuffers: Map<string, TaskLog[]>;
+    /**
+     * this list of ws sub to the task managers events
+     */
+    protected subscribers: Set<WebSocket>;
+    /**
+     * stores filters
+     */
+    protected logMatchers: Map<WebSocket, (log: TaskLog) => boolean>;
+    protected TOTAL_LOGS_COUNT: number;
+    /**
+     * Lifecycle status of the task manager.
+     * Can be 'init', 'running', 'stopped', or 'done'.
+     */
+    protected status: string;
+    private currentRunningStartPromise?;
+    /**
+     * Event emitter for task- and op-level lifecycle events.
+     */
+    protected events: EventEmitter;
+    constructor(provider: Provider, repository: NodeRepository, job: string, project: string, definition?: JobDefinition | undefined);
+    runTaskManagerOperation: (flow: Flow, op: Operation<OperationType>, dependent: string[]) => Promise<void>;
+    restartTaskManagerOperation: (group: string, opId: string) => Promise<void>;
+    stopTaskManagerOperation: (group: string, opId: string) => Promise<void>;
+    stopTaskManagerGroupOperations: (group: string) => Promise<void>;
+    restartTaskManagerGroupOperations: (group: string) => Promise<void>;
+    moveTaskManagerGroupOperations: (group: string) => Promise<void>;
+    stopAllTaskManagerOperations: (reason: StopReason) => void;
+    createOperationMap: () => Map<string, Operation<OperationType>>;
+    createExecutionPlan: () => ExecutionContext[];
+    createDependencyMap: () => Map<string, DependencyContext>;
+    validateExecutionPlan: () => void;
+    getOperationsStatus: () => Record<string, string | null>;
+    getOperationStatus: (id: string) => Record<string, string | null>;
+    getCurrentGroup: () => string | undefined;
+    getCurrentGroupStatus: () => Record<string, string | null>;
+    getGroupStatus: (group: string) => Record<string, string | null>;
+    addlog: (log: TaskLog) => void;
+    getLogsByOp: (opid: string) => TaskLog[];
+    getLogsByGroup: (group: string) => TaskLog[];
+    getAllLogs: () => TaskLog[];
+    subscribe: (ws: WebSocket, matcher: (log: TaskLog) => boolean) => void;
+    unsubscribe: (ws: WebSocket) => void;
+    setResult: (opId: string, key: string, value: any) => void;
+    setResults: (opId: string, values: Record<string, any>) => void;
+    setHost: (opId: string, host: string) => void;
+    setDefaults: (flowId: string, project: string, jobDefinition: JobDefinition) => void;
+    rehydrateEndpointsForOperation: (flowId: string, project: string, jobDefinition: JobDefinition, opId: string) => void;
+    getByPath: (opId: string, path: string) => any;
+    resolveLiteralsInString: (input: string) => string;
+    interpolate: InterpolateFn;
+    interpolateOperation: InterpolateOpFn;
+    transformCollections: InterpolateOpFn;
+    /**
+     * Returns the unified event emitter for this task manager.
+     */
+    getEventsEmitter(): EventEmitter;
+    /**
+     * Registers an op-level emitter and relays its relevant events to the
+     * task-level unified emitter. Also tracks the emitter in operationsEventEmitters.
+     */
+    protected registerAndRelayOpEmitter(opId: string, emitter: EventEmitter): void;
+    /**
+     * Prepares the TaskManager for execution by performing all necessary setup steps.
+     *
+     * This method performs two key operations:
+     *
+     *  `build()`:
+     *    - Generates a map of all operations for fast lookup.
+     *    - Creates the execution plan based on operation groups and dependencies.
+     *    - Validates the structure of the plan to catch any misconfigurations early.
+     *
+     *  `init()`:
+     *    - Initializes the task's persistent flow state in the repository.
+     *    - Skips initialization if the flow already exists (resumable/restartable design).
+     *
+     * Call this once before `start()` to ensure the task manager is fully ready.
+     */
+    bootstrap(): void;
+    /**
+     * Starts the execution of the job by processing each group in the execution plan.
+     * Tracks the full lifecycle including flow state updates and dynamic operations.
+     *
+     * Execution Lifecycle:
+     * - If already started, returns the tracked lifecycle promise.
+     * - Sets status to 'running' and updates the repository with start time.
+     * - Iterates through execution groups and runs each op concurrently.
+     * - Uses a dynamic while-loop to ensure all ops (including restarts) finish before advancing.
+     * - After all groups finish, updates the flow state to 'success' or keeps previous status.
+     * - On any uncaught failure, marks the flow as 'failed' with end time.
+     */
+    start(): Promise<void>;
+    /**
+     * Gracefully stops the task manager and all its operations.
+     *
+     * This method:
+     * - Immediately aborts all running operations by triggering the main abort controller.
+     * - Waits for the current `start()` flow to finish, including database updates.
+     * - Ensures `stop()` logic runs only once per job to prevent race conditions.
+     *
+     * Important:
+     * - `stopAllTaskManagerOperations()` is synchronous and triggers cancellation.
+     * - The actual cleanup and final state update (e.g., setting `endTime`) is handled
+     *   by the `start()` method’s final logic.
+     */
+    stop(reason: StopReason): Promise<void>;
+    protected setUpOperationFunc(flow: Flow, id: string, dependent: string[]): Promise<void>;
+    protected trackGroupOperationPromise(opId: string, promise: Promise<void>): Promise<void>;
+    protected getStatus(reason: StopReason, type: 'ops' | 'flow'): Status;
+    protected getOpStateIndex(opId: string): number;
+    private build;
+    private init;
+}
+export {};