@nosana/node 1.0.0-rc

package/dist/NodeManager/node/task/operations/stopTaskManagerOperation.js

@@ -0,0 +1,137 @@
+import { OperationProgressStatuses, StopReasons, } from '../TaskManager.js';
+/**
+ * Publicly exposed method to stop a running operation within the active group.
+ *
+ * This:
+ * - Validates the operation belongs to the current group
+ * - Prevents concurrent mutation using `lockedOperations`
+ * - Aborts the operation's container execution
+ * - Waits for full cleanup (exit/error + container teardown)
+ * - Ensures promise is resolved before continuing
+ *
+ * Usage: await taskManager.stopTaskOperation(groupId, opId)
+ */
+export async function stopTaskManagerOperation(group, opId) {
+    /**
+     * Check if the provided group exists in the execution plan.
+     * If not, the group name is invalid or unregistered.
+     */
+    const groupExists = this.executionPlan.some((ctx) => ctx.group === group);
+    if (!groupExists) {
+        throw new Error(`GROUP_NOT_FOUND`);
+    }
+    /**
+     * If the provided group is not currently active, we still allow a stop attempt
+     */
+    const inProvidedGroup = this.executionPlan
+        .find((ctx) => ctx.group === group)
+        ?.ops.includes(opId);
+    if (!inProvidedGroup) {
+        throw new Error('GROUP_NOT_FOUND');
+    }
+    /**
+     * Prevent concurrent stop or restart operations on the same op.
+     * This lock guards against race conditions or double-aborts.
+     */
+    if (this.lockedOperations.has(opId)) {
+        throw new Error(`OPERATION_${this.lockedOperations.get(opId)}`);
+    }
+    const currentStatus = this.operationStatus.get(opId);
+    if (currentStatus == OperationProgressStatuses.STOPPED) {
+        return;
+    }
+    this.lockedOperations.set(opId, 'STOPPING');
+    this.operationStatus.set(opId, OperationProgressStatuses.STOPPING);
+    const emitter = this.operationsEventEmitters.get(opId);
+    if (emitter) {
+        emitter.emit('log', 'Stopping Operation', 'info');
+    }
+    // notify listeners that flow state changed to reflect STOPPING
+    this.events.emit('flow:updated', {
+        jobId: this.job,
+        opId,
+        type: 'status:stopping',
+    });
+    /**
+     * Retrieve the AbortController for this op.
+     * If it's missing, something went wrong during registration or setup.
+     */
+    const controller = this.abortControllerMap.get(opId);
+    /**
+     * Abort the operation — this will trigger cleanup via its lifecycle handlers.
+     * The container will be stopped and teardown will run automatically.
+     */
+    controller?.abort(StopReasons.STOPPED);
+    /**
+     * Wait for the original promise tied to this operation to resolve.
+     * Even if it fails (e.g., due to abort), we silently swallow the error
+     * since the focus here is cleanup, not success.
+     */
+    const originalPromise = this.currentGroupOperationsPromises.get(opId);
+    if (originalPromise) {
+        try {
+            await originalPromise;
+        }
+        catch {
+            // swallow error, we're only waiting for cleanup
+        }
+    }
+    /**
+     * Ensure we clean up the operation's reference in the promise map
+     * to avoid holding stale references or leaking memory.
+     */
+    this.currentGroupOperationsPromises.delete(opId);
+    // Unlock the operation so it can be restarted or reused later
+    this.lockedOperations.delete(opId);
+    // Ensure final STOPPED state is reflected in memory and repository
+    this.operationStatus.set(opId, OperationProgressStatuses.STOPPED);
+    const index = this.getOpStateIndex(opId);
+    const opState = this.repository.getOpState(this.job, index);
+    const alreadyEnded = !!opState.endTime;
+    if (!alreadyEnded) {
+        this.repository.updateOpState(this.job, index, {
+            status: this.getStatus(StopReasons.STOPPED, 'ops'),
+            endTime: Date.now(),
+        });
+    }
+    this.events.emit('flow:updated', {
+        jobId: this.job,
+        opId,
+        type: 'status:stopped',
+    });
+    try {
+        const flow = this.repository.getFlow(this.job);
+        const secrets = flow?.state?.secrets;
+        let jobSecrets = {};
+        if (secrets &&
+            typeof secrets[this.job] === 'object' &&
+            secrets[this.job] !== 'private' &&
+            secrets[this.job] !== 'public' &&
+            secrets[this.job]) {
+            jobSecrets = secrets[this.job];
+        }
+        let updated = false;
+        const newJobSecrets = {};
+        for (const [exposeId, value] of Object.entries(jobSecrets)) {
+            const v = value;
+            if (v && typeof v === 'object' && v.opID === opId) {
+                newJobSecrets[exposeId] = { ...v, status: 'OFFLINE' };
+                updated = true;
+            }
+            else {
+                newJobSecrets[exposeId] = v;
+            }
+        }
+        if (updated) {
+            this.repository.updateflowStateSecret(this.job, {
+                [this.job]: newJobSecrets,
+            });
+            this.events.emit('flow:updated', {
+                jobId: this.job,
+                opId,
+                type: 'flow:secrets-updated',
+            });
+        }
+    }
+    catch { }
+}

package/dist/NodeManager/node/utils/convertFromBytes.d.ts

@@ -0,0 +1,4 @@
+export declare function convertFromBytes(bytes: number, toFormat?: 'gb' | 'mb' | 'kb'): {
+    value: number;
+    format: 'gb' | 'mb' | 'kb';
+};

package/dist/NodeManager/node/utils/convertFromBytes.js

@@ -0,0 +1,11 @@
+export function convertFromBytes(bytes, toFormat) {
+    let value = bytes / 1024;
+    if ((value < 1024 && !toFormat) || toFormat === 'kb') {
+        return { value: Number(value.toFixed(2)), format: 'kb' };
+    }
+    value = value / 1024;
+    if ((value < 1024 && !toFormat) || toFormat === 'mb') {
+        return { value: Number(value.toFixed(2)), format: 'mb' };
+    }
+    return { value: Number((value / 1024).toFixed(2)), format: 'gb' };
+}

package/dist/NodeManager/node/utils/extractLogsAndResultsFromLogBuffer.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { OperationResults, Log } from '@nosana/sdk';
+export declare function extractLogsAndResultsFromLogBuffer(logBuffer: Buffer, operationResults: OperationResults | undefined, expiryTimeout?: number): {
+    logs: Log[];
+    results: {} | undefined;
+};

package/dist/NodeManager/node/utils/extractLogsAndResultsFromLogBuffer.js

@@ -0,0 +1,34 @@
+import { parseBuffer } from '../../provider/utils/parseBuffer.js';
+import { createResultsObject, extractResultFromLog, } from './extractResultsFromLogs.js';
+export function extractLogsAndResultsFromLogBuffer(logBuffer, operationResults, expiryTimeout = 180) {
+    const logs = [];
+    const results = operationResults
+        ? createResultsObject(operationResults)
+        : undefined;
+    let index = 0, running = true;
+    const timer = setTimeout(() => {
+        running = false;
+        logs.push({
+            type: 'nodeerr',
+            log: 'Took too long to retrive all logs',
+            timestamp: new Date().toISOString(),
+        });
+    }, expiryTimeout);
+    while (index < logBuffer.length && running) {
+        const log = parseBuffer(logBuffer, index);
+        logs.push(log);
+        if (results && operationResults) {
+            extractResultFromLog(results, log, operationResults);
+        }
+        if (logs.length >= 25000) {
+            running = false;
+            logs.push({
+                type: 'nodeerr',
+                log: 'Found too many logs...',
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+    clearTimeout(timer);
+    return { logs, results };
+}

package/dist/NodeManager/node/utils/extractResultsFromLogs.d.ts

@@ -0,0 +1,18 @@
+import { OperationResults, Log } from '@nosana/sdk';
+/**
+ * Initiates results object to retain order from job definition
+ * @param operationResults OperationResults | undefined
+ * @returns {Object.<string, string | string[]>} initiated object
+ */
+export declare function createResultsObject(operationResults: OperationResults): {
+    [key: string]: string | string[];
+};
+/**
+ * extracts operation results from log
+ * @param resultObj
+ * @param logObj
+ * @param operationResults OperationResults
+ */
+export declare function extractResultFromLog(resultObj: {
+    [key: string]: string | string[];
+}, logObj: Log, operationResults: OperationResults): void;

package/dist/NodeManager/node/utils/extractResultsFromLogs.js

@@ -0,0 +1,37 @@
+/**
+ * Initiates results object to retain order from job definition
+ * @param operationResults OperationResults | undefined
+ * @returns {Object.<string, string | string[]>} initiated object
+ */
+export function createResultsObject(operationResults) {
+    return Object.keys(operationResults).reduce((obj, key) => ((obj[key] = []), obj), {});
+}
+/**
+ * extracts operation results from log
+ * @param resultObj
+ * @param logObj
+ * @param operationResults OperationResults
+ */
+export function extractResultFromLog(resultObj, logObj, operationResults) {
+    const { type, log } = logObj;
+    for (let [filterName, filter] of Object.entries(operationResults)) {
+        let regex;
+        let logType;
+        if (typeof filter === 'string')
+            regex = filter;
+        else
+            (regex = filter.regex), (logType = filter.logType);
+        if ((logType === undefined || logType?.includes(type)) && log) {
+            try {
+                const regexExp = new RegExp(regex === '*' ? '/*' : regex);
+                resultObj[filterName] = [
+                    ...resultObj[filterName],
+                    ...(log.match(regexExp) || []),
+                ];
+            }
+            catch (err) {
+                resultObj[filterName] = `${err}`;
+            }
+        }
+    }
+}

package/dist/NodeManager/node/utils/generateRandomId.d.ts

@@ -0,0 +1 @@
+export declare function generateRandomId(length: number): string;

package/dist/NodeManager/node/utils/generateRandomId.js

@@ -0,0 +1,3 @@
+export function generateRandomId(length) {
+    return [...Array(length)].map(() => Math.random().toString(36)[2]).join('');
+}

package/dist/NodeManager/node/utils/multiProgressBarReporter.d.ts

@@ -0,0 +1,16 @@
+import { Options } from 'cli-progress';
+export declare class MultiProgressBarReporter {
+    private running;
+    private current;
+    start(name: string, optProgressBar: Options): void;
+    update(event: {
+        status: 'Pulling fs layer' | 'Downloading' | 'Download complete';
+        progressDetail: {
+            current: number;
+            total: number;
+        };
+        id: string;
+    }): void;
+    stop(name: string): string;
+    completed(): Promise<void>;
+}

package/dist/NodeManager/node/utils/multiProgressBarReporter.js

@@ -0,0 +1,22 @@
+export class MultiProgressBarReporter {
+    constructor() {
+        this.running = false;
+        this.current = {
+            optProgressBar: null,
+        };
+    }
+    start(name, optProgressBar) {
+        this.current = {
+            optProgressBar,
+        };
+        this.running = true;
+    }
+    update(event) { }
+    stop(name) {
+        this.running = false;
+        return name;
+    }
+    async completed() {
+        this.running = false;
+    }
+}

package/dist/NodeManager/node/utils/poll.d.ts

@@ -0,0 +1,5 @@
+import { Run } from '@nosana/sdk';
+export declare function pollForRun(getRun: () => Run | undefined, interval?: number): {
+    promise: Promise<unknown>;
+    cancel: () => void;
+};

package/dist/NodeManager/node/utils/poll.js

@@ -0,0 +1,25 @@
+export function pollForRun(getRun, interval = 200) {
+    let poll;
+    let cancelled = false;
+    const promise = new Promise((resolve) => {
+        poll = setInterval(() => {
+            if (cancelled)
+                return;
+            try {
+                const run = getRun();
+                if (run) {
+                    clearInterval(poll);
+                    resolve(run);
+                }
+            }
+            catch { }
+        }, interval);
+    });
+    return {
+        promise,
+        cancel: () => {
+            cancelled = true;
+            clearInterval(poll);
+        },
+    };
+}

package/dist/NodeManager/node/utils/progressBarReporter.d.ts

@@ -0,0 +1,9 @@
+import { Options, Preset } from 'cli-progress';
+export declare class ProgressBarReporter {
+    private running;
+    private current;
+    start(name: string, optProgressBar: Options, total: number, startValue: number, payload?: object, progressBarPreset?: Preset): Promise<void>;
+    update(current: number, payload?: object): Promise<void>;
+    stop(name: string): Promise<string>;
+    completed(): Promise<void>;
+}

package/dist/NodeManager/node/utils/progressBarReporter.js

@@ -0,0 +1,28 @@
+export class ProgressBarReporter {
+    constructor() {
+        this.running = false;
+        this.current = {
+            optProgressBar: null,
+            total: 0,
+            startValue: 0,
+        };
+    }
+    async start(name, optProgressBar, total, startValue, payload, progressBarPreset) {
+        this.current = {
+            optProgressBar,
+            total,
+            startValue,
+            payload,
+            progressBarPreset,
+        };
+        this.running = true;
+    }
+    async update(current, payload) { }
+    async stop(name) {
+        this.running = false;
+        return name;
+    }
+    async completed() {
+        this.running = false;
+    }
+}

package/dist/NodeManager/provider/ContainerStateManager.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import type EventEmitter from 'events';
+import type Dockerode from 'dockerode';
+import type { RestartPolicy } from '@nosana/sdk';
+type ContainerState = 'starting' | 'running' | 'exited' | 'restarting';
+export declare class ContainerStateManager {
+    private container;
+    private controller;
+    private emitter;
+    private restartPolicy;
+    private state;
+    private exitedCheckCount;
+    private lastLogTimestamp;
+    private readonly EXITED_CHECKS_REQUIRED;
+    private currentLogStream;
+    private pollingInterval;
+    constructor(container: Dockerode.Container, controller: AbortController, emitter: EventEmitter, restartPolicy: RestartPolicy | undefined);
+    getState(): ContainerState;
+    startMonitoring(): Promise<void>;
+    private attachLogStream;
+    waitForExit(): Promise<void>;
+    stopMonitoring(): void;
+}
+export {};

package/dist/NodeManager/provider/ContainerStateManager.js

@@ -0,0 +1,122 @@
+import { parseBuffer } from './utils/parseBuffer.js';
+export class ContainerStateManager {
+    constructor(container, controller, emitter, restartPolicy) {
+        this.container = container;
+        this.controller = controller;
+        this.emitter = emitter;
+        this.restartPolicy = restartPolicy;
+        this.state = 'starting';
+        this.exitedCheckCount = 0;
+        this.lastLogTimestamp = 0; // Unix timestamp in seconds from actual container logs
+        this.EXITED_CHECKS_REQUIRED = 3; // Require 3 consecutive checks before confirming exit
+        this.currentLogStream = null;
+        this.pollingInterval = null;
+    }
+    getState() {
+        return this.state;
+    }
+    async startMonitoring() {
+        await this.attachLogStream();
+        if (!this.restartPolicy) {
+            this.container
+                .wait({ abortSignal: this.controller.signal })
+                .finally(() => {
+                this.state = 'exited';
+            });
+            return;
+        }
+        this.pollingInterval = setInterval(async () => {
+            if (this.controller.signal.aborted) {
+                this.stopMonitoring();
+                return;
+            }
+            try {
+                const inspectInfo = await this.container.inspect();
+                let inspectedState = inspectInfo.State.Status.toLowerCase();
+                if (['running', 'restarting'].includes(inspectedState)) {
+                    this.exitedCheckCount = 0;
+                    this.state = inspectedState;
+                    return;
+                }
+                this.exitedCheckCount++;
+                if (this.exitedCheckCount >= this.EXITED_CHECKS_REQUIRED) {
+                    this.state = 'exited';
+                }
+            }
+            catch (error) {
+                this.exitedCheckCount++;
+                if (this.exitedCheckCount >= this.EXITED_CHECKS_REQUIRED) {
+                    this.state = 'exited';
+                    this.stopMonitoring();
+                }
+            }
+        }, 1000);
+    }
+    async attachLogStream() {
+        try {
+            this.currentLogStream = await this.container.logs({
+                stdout: true,
+                stderr: true,
+                follow: true,
+                timestamps: true,
+                since: this.lastLogTimestamp + 1,
+                abortSignal: this.controller.signal,
+            });
+            this.currentLogStream.on('data', (data) => {
+                const { log, type, timestamp } = parseBuffer(data);
+                if (!log)
+                    return;
+                this.lastLogTimestamp = Math.floor(new Date(timestamp).getTime() / 1000);
+                this.emitter.emit('log', log, type, 'container', timestamp);
+            });
+            this.currentLogStream.on('close', () => {
+                this.currentLogStream = null;
+                if (this.state === 'running' && !this.controller.signal.aborted) {
+                    setTimeout(() => this.attachLogStream(), 100);
+                }
+            });
+            // Clean up on abort
+            const abortHandler = () => {
+                this.currentLogStream?.removeAllListeners();
+                if (this.currentLogStream &&
+                    'destroy' in this.currentLogStream &&
+                    typeof this.currentLogStream.destroy === 'function') {
+                    this.currentLogStream.destroy();
+                }
+                this.currentLogStream = null;
+            };
+            this.controller.signal.addEventListener('abort', abortHandler, {
+                once: true,
+            });
+        }
+        catch (error) {
+            if (this.state === 'running' && !this.controller.signal.aborted) {
+                setTimeout(() => this.attachLogStream(), 1000);
+            }
+        }
+    }
+    async waitForExit() {
+        return new Promise((resolve) => {
+            const checkInterval = setInterval(() => {
+                if (this.state === 'exited' || this.controller.signal.aborted) {
+                    clearInterval(checkInterval);
+                    resolve();
+                }
+            }, 500);
+        });
+    }
+    stopMonitoring() {
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = null;
+        }
+        if (this.currentLogStream) {
+            this.currentLogStream.removeAllListeners();
+            if ('destroy' in this.currentLogStream &&
+                typeof this.currentLogStream.destroy === 'function') {
+                this.currentLogStream.destroy();
+            }
+            this.currentLogStream = null;
+        }
+    }
+}

package/dist/NodeManager/provider/ExposedPortHealthCheck.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { ExposedPort } from '@nosana/sdk';
+import Dockerode from 'dockerode';
+import EventEmitter from 'events';
+export declare class ExposedPortHealthCheck {
+    private exposedPortMap;
+    private frpcContainer;
+    private containerName;
+    private startupIntervalMs;
+    private continuousIntervalMs;
+    /**
+     * Tracks job previous state to show change in state of job mainly when going from failed to success.
+     */
+    private healthStatus;
+    private jobEmitter;
+    private intervals;
+    private flowId;
+    constructor(flowId: string, frpcContainer: Dockerode.Container, jobEmitter: EventEmitter, containerName: string, startupIntervalMs?: number, continuousIntervalMs?: number);
+    addExposedPortsMap(exposedPortMap: Map<string, ExposedPort>): void;
+    startServiceExposedUrlHealthCheck(): void;
+    private startStartupHealthCheck;
+    private startContinuousHealthCheck;
+    stopHealthCheckForId(id: string): void;
+    stopAllHealthChecks(): void;
+    private checkPortHealth;
+    private runHttpHealthCheck;
+    private runWebSocketHealthCheck;
+    private execCommand;
+}