@nosana/node 1.0.0-rc

package/dist/NodeManager/node/task/globalStore/transformCollections.js

@@ -0,0 +1,152 @@
+const SpreadMarker = {
+    key: '__spread__',
+    objectHandler: (raw) => {
+        const parse = (label, v) => {
+            const obj = typeof v === 'string'
+                ? (() => {
+                    try {
+                        return JSON.parse(v);
+                    }
+                    catch (e) {
+                        throw new Error(`${label} is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                })()
+                : v;
+            if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+                throw new Error(`${label} must be a JSON object`);
+            }
+            return obj;
+        };
+        return parse('__spread__', raw);
+    },
+    arrayHandler: (raw, chunked) => {
+        const parse = (label, v, isChunked) => {
+            let arr = v;
+            if (typeof v === 'string') {
+                // Single JSON string
+                try {
+                    arr = JSON.parse(v);
+                }
+                catch (e) {
+                    throw new Error(`${label} is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+            else if (isChunked &&
+                Array.isArray(v) &&
+                v.every((item) => typeof item === 'string')) {
+                // Chunked JSON array - join strings and parse
+                const joined = v.join('');
+                try {
+                    arr = JSON.parse(joined);
+                }
+                catch (e) {
+                    throw new Error(`${label} chunked array is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+            if (!Array.isArray(arr)) {
+                throw new Error(`${label} must be a JSON array`);
+            }
+            return arr.flat();
+        };
+        return parse('__spread__', raw, chunked);
+    },
+};
+const PairsMarker = {
+    key: '__pairs__',
+    objectHandler: (raw) => {
+        const parseArray = (label, v) => {
+            const parsed = typeof v === 'string'
+                ? (() => {
+                    try {
+                        return JSON.parse(v);
+                    }
+                    catch (e) {
+                        throw new Error(`${label} is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                })()
+                : v;
+            if (!Array.isArray(parsed)) {
+                throw new Error(`${label} must be a JSON array`);
+            }
+            return parsed;
+        };
+        const arr = parseArray('__pairs__', raw);
+        const out = {};
+        for (const it of arr) {
+            if (!it || typeof it !== 'object' || Array.isArray(it)) {
+                throw new Error(`__pairs__ items must be objects`);
+            }
+            const rec = it;
+            const key = rec.key;
+            const value = rec.value;
+            if (typeof key !== 'string') {
+                throw new Error(`__pairs__ item.key must be string`);
+            }
+            out[key] = value ?? '';
+        }
+        return out;
+    },
+    arrayHandler: (raw) => {
+        const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        if (!Array.isArray(parsed))
+            throw new Error(`__pairs__ must be a JSON array`);
+        return parsed;
+    },
+};
+export const DefaultCollectionMarkers = [
+    SpreadMarker,
+    PairsMarker,
+];
+export function transformCollections(op, overwrite = true) {
+    const markers = DefaultCollectionMarkers;
+    const isMarkerKey = (k) => markers.some((m) => m.key === k);
+    const getMarker = (k) => markers.find((m) => m.key === k);
+    const visit = (node) => {
+        if (Array.isArray(node)) {
+            const out = [];
+            for (const el0 of node) {
+                if (el0 && typeof el0 === 'object' && !Array.isArray(el0)) {
+                    const entries = Object.entries(el0);
+                    const markerEntry = entries.find(([k]) => isMarkerKey(k));
+                    if (markerEntry) {
+                        const [mk, raw] = markerEntry;
+                        const spec = getMarker(mk);
+                        if (spec?.arrayHandler) {
+                            const items = spec
+                                .arrayHandler(raw, el0.chunked === true)
+                                .map(visit);
+                            out.push(...items);
+                            continue;
+                        }
+                    }
+                }
+                out.push(visit(el0));
+            }
+            return out;
+        }
+        if (node && typeof node === 'object') {
+            const obj = node;
+            const base = {};
+            for (const [k, v] of Object.entries(obj)) {
+                if (!isMarkerKey(k))
+                    base[k] = visit(v);
+            }
+            for (const [k, raw] of Object.entries(obj)) {
+                if (!isMarkerKey(k))
+                    continue;
+                const spec = getMarker(k);
+                if (!spec?.objectHandler)
+                    continue;
+                const patch = spec.objectHandler(raw);
+                for (const [pk, pv] of Object.entries(patch)) {
+                    if (overwrite || !(pk in base))
+                        base[pk] = pv;
+                }
+            }
+            return base;
+        }
+        return node;
+    };
+    const nextArgs = visit(op.args);
+    return { ...op, args: nextArgs };
+}

package/dist/NodeManager/node/task/helpers/createDefaultOpState.d.ts

@@ -0,0 +1,2 @@
+import type { OperationType, Operation, OpState } from '@nosana/sdk';
+export declare function createDefaultOpState(op: Operation<OperationType>): OpState;

package/dist/NodeManager/node/task/helpers/createDefaultOpState.js

@@ -0,0 +1,20 @@
+export function createDefaultOpState(op) {
+    return {
+        operationId: op.id,
+        group: op.execution?.group ?? op.id,
+        providerId: null,
+        status: 'init',
+        startTime: null,
+        endTime: null,
+        exitCode: null,
+        logs: [],
+        errors: [],
+        diagnostics: {
+            reason: {
+                hostShutDown: false,
+                jobStopped: false,
+                jobExpired: false,
+            },
+        },
+    };
+}

package/dist/NodeManager/node/task/helpers/createInitialFlow.d.ts

@@ -0,0 +1,8 @@
+import { JobDefinition, Operation, OperationType } from '@nosana/sdk';
+import { Flow } from '@nosana/sdk';
+/**
+ * Creates the initial flow structure for a given job.
+ *
+ * This sets up the default flow object with placeholder metadata and default op states.
+ */
+export declare function createInitialFlow(jobId: string, project: string, definition: JobDefinition, operations: Operation<OperationType>[], status: string, timestamp: number, error?: Error | unknown): Flow;

package/dist/NodeManager/node/task/helpers/createInitialFlow.js

@@ -0,0 +1,24 @@
+import { createDefaultOpState } from './createDefaultOpState.js';
+/**
+ * Creates the initial flow structure for a given job.
+ *
+ * This sets up the default flow object with placeholder metadata and default op states.
+ */
+export function createInitialFlow(jobId, project, definition, operations, status, timestamp, error) {
+    const flow = {
+        id: jobId,
+        jobDefinition: definition,
+        project,
+        state: {
+            status,
+            startTime: timestamp,
+            endTime: null,
+            secrets: {},
+            opStates: operations.map(createDefaultOpState),
+        },
+    };
+    if (error) {
+        flow.state.errors = [error instanceof Error ? error.message : error];
+    }
+    return flow;
+}

package/dist/NodeManager/node/task/loggers/logManager.d.ts

@@ -0,0 +1,8 @@
+import TaskManager, { TaskLog } from '../TaskManager.js';
+import WebSocket from 'ws';
+export declare function addLog(this: TaskManager, log: TaskLog): void;
+export declare function getLogsByOp(this: TaskManager, opId: string): TaskLog[];
+export declare function getLogsByGroup(this: TaskManager, group: string): TaskLog[];
+export declare function getAllLogs(this: TaskManager): TaskLog[];
+export declare function subscribe(this: TaskManager, ws: WebSocket, matcher: (log: TaskLog) => boolean): void;
+export declare function unsubscribe(this: TaskManager, ws: WebSocket): void;

package/dist/NodeManager/node/task/loggers/logManager.js

@@ -0,0 +1,54 @@
+const MAX_LOGS_PER_OP = 10000000;
+// Ensure strictly increasing timestamps per TaskManager to avoid mis-ordered logs
+const lastTimestampByTask = new WeakMap();
+export function addLog(log) {
+    // Normalize timestamp to be strictly increasing per TaskManager instance
+    const prev = lastTimestampByTask.get(this) || 0;
+    if (typeof log.timestamp !== 'number' || !isFinite(log.timestamp)) {
+        log.timestamp = prev + 1;
+    }
+    else if (log.timestamp <= prev) {
+        log.timestamp = prev + 1;
+    }
+    lastTimestampByTask.set(this, log.timestamp);
+    if (!this.opLogBuffers.has(log.opId)) {
+        this.opLogBuffers.set(log.opId, []);
+    }
+    const buffer = this.opLogBuffers.get(log.opId);
+    buffer.push(log);
+    if (buffer.length > MAX_LOGS_PER_OP)
+        buffer.shift();
+    for (const ws of this.subscribers) {
+        const matcher = this.logMatchers.get(ws);
+        if (matcher && matcher(log)) {
+            try {
+                ws.send(JSON.stringify({ path: 'flog', data: JSON.stringify(log) }));
+            }
+            catch (_) { }
+        }
+    }
+}
+export function getLogsByOp(opId) {
+    return this.opLogBuffers.get(opId) || [];
+}
+export function getLogsByGroup(group) {
+    const logs = [];
+    for (const buffer of this.opLogBuffers.values()) {
+        logs.push(...buffer.filter((log) => log.group === group));
+    }
+    return logs;
+}
+export function getAllLogs() {
+    return Array.from(this.opLogBuffers.values()).flat();
+}
+export function subscribe(ws, matcher) {
+    this.subscribers.add(ws);
+    this.logMatchers.set(ws, matcher);
+    ws.on('close', () => {
+        unsubscribe.call(this, ws);
+    });
+}
+export function unsubscribe(ws) {
+    this.subscribers.delete(ws);
+    this.logMatchers.delete(ws);
+}

package/dist/NodeManager/node/task/operations/getOperationsInfos.d.ts

@@ -0,0 +1,6 @@
+import TaskManager from '../TaskManager.js';
+export declare function getOperationsStatus(this: TaskManager): Record<string, string>;
+export declare function getOperationStatus(this: TaskManager, id: string): Record<string, string | null>;
+export declare function getCurrentGroup(this: TaskManager): string | undefined;
+export declare function getCurrentGroupStatus(this: TaskManager): Record<string, string | null>;
+export declare function getGroupStatus(this: TaskManager, group: string): Record<string, string | null>;

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

@@ -0,0 +1,33 @@
+export function getOperationsStatus() {
+    return Object.fromEntries(this.operationStatus);
+}
+export function getOperationStatus(id) {
+    const status = this.operationStatus.get(id);
+    return {
+        [id]: status ?? null,
+    };
+}
+export function getCurrentGroup() {
+    return this.currentGroup;
+}
+export function getCurrentGroupStatus() {
+    const record = {};
+    const group = this.currentGroup;
+    const context = this.executionPlan.find((ctx) => ctx.group === group);
+    if (!context)
+        return record;
+    for (const opId of context.ops) {
+        record[opId] = this.operationStatus.get(opId) ?? null;
+    }
+    return record;
+}
+export function getGroupStatus(group) {
+    const record = {};
+    const context = this.executionPlan.find((ctx) => ctx.group === group);
+    if (!context)
+        return record;
+    for (const opId of context.ops) {
+        record[opId] = this.operationStatus.get(opId) ?? null;
+    }
+    return record;
+}

package/dist/NodeManager/node/task/operations/moveTaskManagerGroupOperation.d.ts

@@ -0,0 +1,2 @@
+import TaskManager from '../TaskManager.js';
+export declare function moveTaskManagerGroupOperations(this: TaskManager, group: string): Promise<void>;

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

@@ -0,0 +1,65 @@
+export async function moveTaskManagerGroupOperations(group) {
+    /**
+     * Look up the group context to get its operation IDs.
+     * If the group doesn't exist in the execution plan, it's invalid.
+     */
+    const groupContext = this.executionPlan.find((ctx) => ctx.group === group);
+    if (!groupContext) {
+        throw new Error('GROUP_NOT_FOUND');
+    }
+    /**
+     * Ensure we're currently within the provided group context before proceeding.
+     * Prevents stopping inactive or completed groups.
+     */
+    if (this.currentGroup == group) {
+        throw new Error('GROUP_ACTIVE');
+    }
+    const currentGroupContext = this.executionPlan.find((ctx) => ctx.group === this.currentGroup);
+    if (!currentGroupContext) {
+        throw new Error('GROUP_NOT_FOUND');
+    }
+    /**
+     * The following block creates a "placeholder promise" that we temporarily insert into the group’s
+     * operation map. This ensures that even if all the original ops complete while we're restarting,
+     * the group will not advance to the next one until we explicitly release this block.
+     *
+     * This is CRITICAL to prevent race conditions where the restart is too late, and the system
+     * thinks the group has completed.
+     */
+    const groupHold = (() => {
+        let release;
+        const placeholder = new Promise((res) => (release = res));
+        const abortHandler = () => {
+            release();
+            this.mainAbortController.signal.removeEventListener('abort', abortHandler);
+        };
+        this.mainAbortController.signal.addEventListener('abort', abortHandler);
+        return {
+            groupHoldPromisePlaceHolder: placeholder,
+            releaseGroupOperationBlock: () => {
+                release();
+                this.mainAbortController.signal.removeEventListener('abort', abortHandler);
+            },
+        };
+    })();
+    // Use a special ID to register this placeholder in the group tracking map
+    // The op will still retain its original ID for restart purposes
+    const placeholderId = `${group}::restart-group`;
+    this.trackGroupOperationPromise(placeholderId, groupHold.groupHoldPromisePlaceHolder);
+    if (this.currentGroup) {
+        await this.stopTaskManagerGroupOperations(this.currentGroup);
+    }
+    /**
+     * update the current group to the group we about to start
+     */
+    this.currentGroup = group;
+    /**
+     * restart the new current group
+     */
+    await this.restartTaskManagerGroupOperations(group);
+    /**
+     * Now that we've re-launched the op and it's being tracked,
+     * we can safely release the group hold so the group can eventually complete.
+     */
+    groupHold.releaseGroupOperationBlock();
+}

package/dist/NodeManager/node/task/operations/restartTaskManagerGroupOperation.d.ts

@@ -0,0 +1,10 @@
+import TaskManager from '../TaskManager.js';
+/**
+ * Restarts all operations in the given group sequentially.
+ *
+ * This method:
+ * - Validates the group exists and is active
+ * - Iterates through ops one-by-one, restarting each in order
+ * - If any restart fails, it logs and continues to the next op
+ */
+export declare function restartTaskManagerGroupOperations(this: TaskManager, group: string): Promise<void>;

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

@@ -0,0 +1,37 @@
+/**
+ * Restarts all operations in the given group sequentially.
+ *
+ * This method:
+ * - Validates the group exists and is active
+ * - Iterates through ops one-by-one, restarting each in order
+ * - If any restart fails, it logs and continues to the next op
+ */
+export async function restartTaskManagerGroupOperations(group) {
+    /**
+     * Look up the group and its operation list.
+     * If the group doesn't exist in the plan, it's invalid.
+     */
+    const groupContext = this.executionPlan.find((ctx) => ctx.group === group);
+    if (!groupContext) {
+        throw new Error('GROUP_NOT_FOUND');
+    }
+    /**
+     * Ensure the provided group is currently active.
+     * Restarting ops from inactive or future groups is not allowed.
+     */
+    if (this.currentGroup !== group) {
+        throw new Error('GROUP_NOT_ACTIVE');
+    }
+    /**
+     * Restart each operation one at a time.
+     * If any restart fails, log and continue.
+     */
+    for (const id of groupContext.ops) {
+        try {
+            await this.restartTaskManagerOperation(group, id);
+        }
+        catch (err) {
+            console.warn(`Failed to restart operation ${id}:`, err);
+        }
+    }
+}

package/dist/NodeManager/node/task/operations/restartTaskManagerOperation.d.ts

@@ -0,0 +1,14 @@
+import TaskManager from '../TaskManager.js';
+/**
+ * Restarts a single operation (`opId`) within the currently running group (`group`).
+ *
+ * This function is meant to be rebound to a `TaskManager` instance using `.bind(this)`, so it can
+ * interact with all internal state and methods just like a native class method.
+ *
+ * The restart process:
+ * - Aborts the operation's current execution
+ * - Waits for its cleanup to complete
+ * - Holds the group's completion to avoid premature advancement
+ * - Re-executes the same operation within the current group
+ */
+export declare function restartTaskManagerOperation(this: TaskManager, group: string, opId: string): Promise<void>;

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

@@ -0,0 +1,117 @@
+import { OperationProgressStatuses } from '../TaskManager.js';
+/**
+ * Restarts a single operation (`opId`) within the currently running group (`group`).
+ *
+ * This function is meant to be rebound to a `TaskManager` instance using `.bind(this)`, so it can
+ * interact with all internal state and methods just like a native class method.
+ *
+ * The restart process:
+ * - Aborts the operation's current execution
+ * - Waits for its cleanup to complete
+ * - Holds the group's completion to avoid premature advancement
+ * - Re-executes the same operation within the current group
+ */
+export async function restartTaskManagerOperation(group, opId) {
+    /**
+     * Check if the provided group actually exists in the execution plan.
+     * If not, it likely means the group name is invalid or not registered.
+     */
+    const groupExists = this.executionPlan.some((ctx) => ctx.group === group);
+    if (!groupExists)
+        throw new Error(`GROUP_NOT_FOUND`);
+    /**
+     * Only allow restart if the group is the one currently being executed.
+     * This prevents restarting ops from already-finished groups or future ones.
+     */
+    if (this.currentGroup !== group) {
+        throw new Error('GROUP_NOT_ACTIVE');
+    }
+    /**
+     * If the operation is already in the process of being restarted or stopped,
+     * we don't want to allow another concurrent mutation.
+     */
+    if (this.lockedOperations.has(opId)) {
+        throw new Error(`OPERATION_${this.lockedOperations.get(opId)}`);
+    }
+    // Mark this op as "RESTARTING" so no one else touches it mid-process
+    this.lockedOperations.set(opId, 'RESTARTING');
+    this.operationStatus.set(opId, OperationProgressStatuses.RESTARTING);
+    const emitter = this.operationsEventEmitters.get(opId);
+    if (emitter) {
+        emitter.emit('log', 'Restarting Operation', 'info');
+    }
+    /**
+     * Get the controller used to abort this operation's execution.
+     * This should have been set up when the op was first started.
+     */
+    const controller = this.abortControllerMap.get(opId);
+    /**
+     * The following block creates a "placeholder promise" that we temporarily insert into the group’s
+     * operation map. This ensures that even if all the original ops complete while we're restarting,
+     * the group will not advance to the next one until we explicitly release this block.
+     *
+     * This is CRITICAL to prevent race conditions where the restart is too late, and the system
+     * thinks the group has completed.
+     */
+    const groupHold = (() => {
+        let release;
+        const placeholder = new Promise((res) => (release = res));
+        const abortHandler = () => {
+            release();
+            this.mainAbortController.signal.removeEventListener('abort', abortHandler);
+        };
+        this.mainAbortController.signal.addEventListener('abort', abortHandler);
+        return {
+            groupHoldPromisePlaceHolder: placeholder,
+            releaseGroupOperationBlock: () => {
+                release();
+                this.mainAbortController.signal.removeEventListener('abort', abortHandler);
+            },
+        };
+    })();
+    // Use a special ID to register this placeholder in the group tracking map
+    // The op will still retain its original ID for restart purposes
+    const placeholderId = `${opId}::restart-block`;
+    this.trackGroupOperationPromise(placeholderId, groupHold.groupHoldPromisePlaceHolder);
+    // Abort the currently running operation
+    // This should trigger container teardown, logs finalization, and state updates
+    controller?.abort('restart');
+    /**
+     * If the operation had already started, wait for it to finish fully (even if it failed).
+     * This avoids stomping over any still-pending teardown work.
+     */
+    const originalPromise = this.currentGroupOperationsPromises.get(opId);
+    if (originalPromise) {
+        try {
+            await originalPromise;
+        }
+        catch {
+            // We intentionally ignore any error here.
+            // Our goal is just to make sure the cleanup is finished, not whether it succeeded.
+        }
+    }
+    /**
+     * Now that the original op has been stopped, we need to restart it.
+     * Get the latest flow data from storage — this could’ve been updated elsewhere in the meantime.
+     */
+    const flow = this.repository.getFlow(this.job);
+    /**
+     * Look up the original operation details.
+     * This should always exist unless something went very wrong.
+     */
+    const op = this.opMap.get(opId);
+    if (!op)
+        throw new Error(`INVALID_OPID`);
+    /**
+     * Re-register the operation for execution and begin tracking it again.
+     * This effectively restarts the operation from scratch.
+     */
+    this.currentGroupOperationsPromises.set(opId, this.trackGroupOperationPromise(opId, this.setUpOperationFunc(flow, opId, [])));
+    /**
+     * Now that we've re-launched the op and it's being tracked,
+     * we can safely release the group hold so the group can eventually complete.
+     */
+    groupHold.releaseGroupOperationBlock();
+    // Finally, unlock the operation so other calls (like restart or stop) can act on it again
+    this.lockedOperations.delete(opId);
+}

package/dist/NodeManager/node/task/operations/runTaskManagerOperation.d.ts

@@ -0,0 +1,21 @@
+import { Operation, OperationType } from '@nosana/sdk';
+import TaskManager from '../TaskManager.js';
+import { Flow } from '@nosana/sdk';
+/**
+ * Executes a full lifecycle of a container-based operation using internal class state.
+ *
+ * This function is intended to be bound to a `TaskManager` instance using `.bind(this)`.
+ * It handles:
+ * - Setup
+ * - Log streaming
+ * - Abort controller registration
+ * - Container execution
+ * - Exit/error handling
+ * - Cleanup
+ *
+ * It uses internal state like `this.repository`, `this.provider`, `this.job`, etc.,
+ * and serves as the core execution driver for all operations.
+ *
+ * Keeps lifecycle doc comments in sync with original `setUpOperationFunc`.
+ */
+export declare function runTaskManagerOperation(this: TaskManager, flow: Flow, op: Operation<OperationType>, dependent: string[]): Promise<void>;