@nosana/node 1.0.0-rc

package/dist/NodeManager/node/task/executions/createExecutionPlan.js

@@ -0,0 +1,36 @@
+/**
+ * Converts the list of operations into a structured execution plan.
+ *
+ * This function focuses only on grouping operations by execution group.
+ * Dependency resolution (dependencies + dependents) is now handled separately
+ * in `createDependencyMap()`.
+ *
+ * Each `ExecutionContext` includes:
+ * - `group`: The logical group name
+ * - `ops`: Array of operations with their `id` only
+ */
+export function createExecutionPlan() {
+    /**
+     * Map of groupName -> [op.id, ...]
+     * Collects which operations belong to which execution group.
+     */
+    const groups = new Map();
+    // Build group structure
+    for (const op of this.operations) {
+        this.setHost(op.id, this.job);
+        const group = op.execution?.group ?? op.id;
+        if (!groups.has(group))
+            groups.set(group, []);
+        groups.get(group).push(op.id);
+    }
+    /**
+     * Construct final execution plan grouped by execution group.
+     * Each op only contains its ID; dependency mapping is separate.
+     */
+    const result = [];
+    for (const [group, opIds] of groups.entries()) {
+        const ops = opIds.map((id) => ({ id }));
+        result.push({ group, ops: opIds });
+    }
+    return result;
+}

package/dist/NodeManager/node/task/executions/createOperationMap.d.ts

@@ -0,0 +1,11 @@
+import TaskManager from '../TaskManager.js';
+import { Operation, OperationType } from '@nosana/sdk';
+/**
+ * Creates a map from operation ID to operation object.
+ *
+ * This is used for fast lookup of operations by ID during validation,
+ * dependency resolution, and execution planning.
+ *
+ * It also ensures that there are no duplicate operation IDs in the job definition.
+ */
+export declare function createOperationMap(this: TaskManager): Map<string, Operation<OperationType>>;

package/dist/NodeManager/node/task/executions/createOperationMap.js

@@ -0,0 +1,34 @@
+/**
+ * Creates a map from operation ID to operation object.
+ *
+ * This is used for fast lookup of operations by ID during validation,
+ * dependency resolution, and execution planning.
+ *
+ * It also ensures that there are no duplicate operation IDs in the job definition.
+ */
+export function createOperationMap() {
+    /**
+     * Initialize a map to store operations and a list to track duplicates.
+     */
+    const map = new Map();
+    const duplicates = [];
+    /**
+     * Iterate over all operations and populate the map.
+     * If an ID is already seen, collect it as a duplicate.
+     */
+    for (const op of this.operations) {
+        if (map.has(op.id)) {
+            duplicates.push(op.id);
+        }
+        else {
+            map.set(op.id, op);
+        }
+    }
+    /**
+     * If any duplicate IDs were found, throw an error immediately.
+     */
+    if (duplicates.length > 0) {
+        throw new Error(`Duplicate operation IDs found: ${duplicates.join(', ')}`);
+    }
+    return map;
+}

package/dist/NodeManager/node/task/executions/validateExecutionPlan.d.ts

@@ -0,0 +1,12 @@
+import TaskManager from '../TaskManager.js';
+/**
+ * Validates the structure and dependencies in the execution plan.
+ *
+ * Checks for:
+ * - Self-dependencies
+ * - Dependencies on undefined operations
+ * - Cross-group dependencies (which are currently disallowed)
+ *
+ * If any validation errors are found, the function throws with a detailed message.
+ */
+export declare function validateExecutionPlan(this: TaskManager): void;

package/dist/NodeManager/node/task/executions/validateExecutionPlan.js

@@ -0,0 +1,48 @@
+/**
+ * Validates the structure and dependencies in the execution plan.
+ *
+ * Checks for:
+ * - Self-dependencies
+ * - Dependencies on undefined operations
+ * - Cross-group dependencies (which are currently disallowed)
+ *
+ * If any validation errors are found, the function throws with a detailed message.
+ */
+export function validateExecutionPlan() {
+    const errors = [];
+    for (const op of this.operations) {
+        const opId = op.id;
+        const dependsOn = op.execution?.depends_on ?? [];
+        /**
+         * Check if the operation depends on itself.
+         */
+        if (dependsOn.includes(opId)) {
+            errors.push(`Invalid dependency: Operation '${opId}' cannot depend on itself.`);
+        }
+        for (const depId of dependsOn) {
+            const depOp = this.opMap.get(depId);
+            /**
+             * If the dependency is not found in the op map, it's invalid.
+             */
+            if (!depOp) {
+                errors.push(`Invalid dependency: Operation '${opId}' depends on non existent op '${depId}'.`);
+                continue;
+            }
+            /**
+             * Check for cross-group dependency violations.
+             */
+            const opGroup = op.execution?.group;
+            const depGroup = depOp.execution?.group;
+            if (opGroup !== depGroup) {
+                errors.push(`Invalid dependency: '${opId}' in group '${opGroup}' depends on '${depId}' in group '${depGroup}'`);
+            }
+        }
+    }
+    /**
+     * If any validation issues were discovered, throw an aggregated error.
+     */
+    if (errors.length > 0) {
+        throw new Error('Execution Plan Validation Failed:\n' +
+            errors.map((e) => `- ${e}`).join('\n'));
+    }
+}

package/dist/NodeManager/node/task/globalStore/finalizeEnv.d.ts

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

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

@@ -0,0 +1,30 @@
+export function finalizeEnvOnOperation(op) {
+    const argsAny = op.args;
+    const env = argsAny?.env;
+    if (!env || typeof env !== 'object' || Array.isArray(env)) {
+        return op;
+    }
+    const toEnvString = (v) => {
+        if (v == null)
+            return '';
+        const t = typeof v;
+        if (t === 'string' || t === 'number' || t === 'boolean' || t === 'bigint') {
+            return String(v);
+        }
+        try {
+            return JSON.stringify(v);
+        }
+        catch {
+            return String(v);
+        }
+    };
+    const newEnv = Object.fromEntries(Object.entries(env).map(([k, v]) => [
+        k,
+        toEnvString(v),
+    ]));
+    const nextArgs = {
+        ...op.args,
+        env: newEnv,
+    };
+    return { ...op, args: nextArgs };
+}

package/dist/NodeManager/node/task/globalStore/getByPath.d.ts

@@ -0,0 +1,2 @@
+import TaskManager from '../TaskManager.js';
+export declare function getByPath(this: TaskManager, opId: string, path: string): any;

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

@@ -0,0 +1,12 @@
+export function getByPath(opId, path) {
+    const op = this.globalOpStore[opId];
+    if (!op)
+        return undefined;
+    if (path === 'host')
+        return op.host;
+    return path.split('.').reduce((acc, key) => {
+        if (acc == null)
+            return undefined;
+        return acc[key];
+    }, op);
+}

package/dist/NodeManager/node/task/globalStore/index.d.ts

@@ -0,0 +1,9 @@
+export { setResult } from './setResult.js';
+export { setResults } from './setResults.js';
+export { setHost } from './setHost.js';
+export { setDefaults, rehydrateEndpointsForOperation } from './setDefaults.js';
+export { getByPath } from './getByPath.js';
+export { resolveLiteralsInString } from './resolveLiteralsInString.js';
+export { interpolate } from './interpolate.js';
+export { interpolateOperation } from './interpolateOperation.js';
+export { transformCollections } from './transformCollections.js';

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

@@ -0,0 +1,9 @@
+export { setResult } from './setResult.js';
+export { setResults } from './setResults.js';
+export { setHost } from './setHost.js';
+export { setDefaults, rehydrateEndpointsForOperation } from './setDefaults.js';
+export { getByPath } from './getByPath.js';
+export { resolveLiteralsInString } from './resolveLiteralsInString.js';
+export { interpolate } from './interpolate.js';
+export { interpolateOperation } from './interpolateOperation.js';
+export { transformCollections } from './transformCollections.js';

package/dist/NodeManager/node/task/globalStore/interpolate.d.ts

@@ -0,0 +1,2 @@
+import TaskManager from '../TaskManager.js';
+export declare function interpolate<T = any>(this: TaskManager, value: T): T;

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

@@ -0,0 +1,16 @@
+export function interpolate(value) {
+    if (typeof value === 'string') {
+        return this.resolveLiteralsInString(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => this.interpolate(v));
+    }
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = this.interpolate(v);
+        }
+        return out;
+    }
+    return value;
+}

package/dist/NodeManager/node/task/globalStore/interpolateOperation.d.ts

@@ -0,0 +1,3 @@
+import { Operation, OperationType } from '@nosana/sdk';
+import TaskManager from '../TaskManager.js';
+export declare function interpolateOperation<T extends OperationType>(this: TaskManager, op: Operation<T>): Operation<T>;

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

@@ -0,0 +1,221 @@
+export function interpolateOperation(op) {
+    // %%ops.<opId>.<path>%% and %%global.<key>%%
+    const LITERAL_RE = /%%(ops|global)\.([^.]+)\.([A-Za-z0-9._-]+)%%/g;
+    const LITERAL_RE_EXACT = /^%%(ops|global)\.([^.]+)\.([A-Za-z0-9._-]+)%%$/;
+    const GLOBAL_RE = /%%(global|globals)\.([^.]+)%%/g;
+    const GLOBAL_RE_EXACT = /^%%(global|globals)\.([^.]+)%%$/;
+    const isPlainObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+    const parseJsonIfLooksLike = (v) => {
+        if (typeof v !== 'string')
+            return v;
+        const s = v.trim();
+        if (!s)
+            return v;
+        const first = s[0];
+        if (first !== '[' && first !== '{')
+            return v;
+        try {
+            return JSON.parse(s);
+        }
+        catch {
+            return v;
+        }
+    };
+    const valueToArrayTokens = (value) => {
+        const v = parseJsonIfLooksLike(value);
+        if (Array.isArray(v)) {
+            const out = [];
+            for (const el of v)
+                out.push(...valueToArrayTokens(el));
+            return out;
+        }
+        if (isPlainObject(v)) {
+            return [v];
+        }
+        if (v == null)
+            return [];
+        return [v]; // preserve primitive type
+    };
+    const valueToSpaceString = (value) => valueToArrayTokens(value)
+        .map((x) => String(x))
+        .join(' ');
+    const getByPathStrict = (opId, path) => {
+        const bucket = this.globalOpStore?.[opId];
+        if (!bucket)
+            return undefined;
+        if (path === 'host')
+            return bucket.host;
+        let cur = bucket;
+        for (const seg of path.split('.')) {
+            cur = cur?.[seg];
+            if (cur == null)
+                return undefined; // treat null/undefined as unresolved
+        }
+        return cur;
+    };
+    const getGlobalByPath = (key, path) => {
+        const value = this.globalStore[key];
+        if (!path)
+            return value;
+        let cur = value;
+        for (const seg of path.split('.')) {
+            cur = cur?.[seg];
+            if (cur == null)
+                return undefined;
+        }
+        return cur;
+    };
+    const resolveRawIfExact = (input) => {
+        // Check 3-part pattern first (%%global.key.path%% or %%ops.opId.path%%)
+        let m = input.match(LITERAL_RE_EXACT);
+        if (m) {
+            const type = m[1]; // "ops" or "global"
+            const opId = m[2];
+            const path = m[3];
+            if (type === 'global') {
+                // Handle %%global.key.subpath%% format
+                let value = getGlobalByPath(opId, path);
+                if (value == null || value === '') {
+                    throw new Error(`Unresolved literal: "${input}" (key="${opId}.${path}")`);
+                }
+                // Parse JSON strings in arrays but don't convert to string
+                if (Array.isArray(value)) {
+                    value = value.map((item) => parseJsonIfLooksLike(item));
+                }
+                else {
+                    value = parseJsonIfLooksLike(value);
+                }
+                return { matched: true, value };
+            }
+            else {
+                // Handle %%ops.opId.path%% format
+                let value = getByPathStrict(opId, path);
+                if (value == null) {
+                    throw new Error(`Unresolved literal: "${input}" (opId="${opId}", path="${path}")`);
+                }
+                // Parse JSON strings in arrays but don't convert to string
+                if (Array.isArray(value)) {
+                    value = value.map((item) => parseJsonIfLooksLike(item));
+                }
+                else {
+                    value = parseJsonIfLooksLike(value);
+                }
+                return { matched: true, value };
+            }
+        }
+        // Check 2-part pattern (%%global.key%%)
+        m = input.match(GLOBAL_RE_EXACT);
+        if (m) {
+            const key = m[2];
+            const value = this.globalStore[key];
+            if (value == null || value === '') {
+                throw new Error(`Unresolved literal: "${input}" (key="${key}")`);
+            }
+            return { matched: true, value };
+        }
+        return { matched: false };
+    };
+    const resolveStringStrict = (input) => {
+        const exact = resolveRawIfExact(input);
+        if (exact.matched)
+            return valueToSpaceString(exact.value);
+        // Handle 3-part patterns first
+        let result = input.replace(LITERAL_RE, (match, type, opId, path) => {
+            if (type === 'global') {
+                const value = getGlobalByPath(opId, path);
+                if (value == null || value === '') {
+                    throw new Error(`Unresolved literal: "${match}" (key="${opId}.${path}")`);
+                }
+                return valueToSpaceString(value);
+            }
+            else {
+                const value = getByPathStrict(opId, path);
+                if (value == null) {
+                    throw new Error(`Unresolved literal: "${match}" (opId="${opId}", path="${path}")`);
+                }
+                return valueToSpaceString(value);
+            }
+        });
+        // Handle 2-part patterns
+        result = result.replace(GLOBAL_RE, (match, prefix, key) => {
+            const value = this.globalStore[key];
+            if (value == null || value === '') {
+                throw new Error(`Unresolved literal: "${match}" (key="${key}")`);
+            }
+            return valueToSpaceString(value);
+        });
+        return result;
+    };
+    const interpolateAnyStrict = (val) => {
+        if (typeof val === 'string') {
+            const raw = resolveRawIfExact(val);
+            if (raw.matched)
+                return raw.value; // normalized later based on origin
+            return resolveStringStrict(val);
+        }
+        if (Array.isArray(val))
+            return val.map(interpolateAnyStrict);
+        if (val && typeof val === 'object') {
+            const out = {};
+            for (const [k, v] of Object.entries(val)) {
+                out[k] = interpolateAnyStrict(v);
+            }
+            return out;
+        }
+        return val; // number | boolean | null | undefined
+    };
+    const interpolatedArgs = interpolateAnyStrict(op.args);
+    const normalizeByOrigin = (value, original) => {
+        if (typeof original === 'string') {
+            // If the resolved value is an array with a single item, return that item directly
+            if (Array.isArray(value) && value.length === 1) {
+                return value[0];
+            }
+            return valueToSpaceString(value);
+        }
+        if (Array.isArray(original)) {
+            const out = [];
+            const pushTokens = (v) => {
+                out.push(...valueToArrayTokens(v));
+            };
+            if (Array.isArray(value)) {
+                for (const el of value)
+                    pushTokens(el);
+            }
+            else {
+                pushTokens(value);
+            }
+            return out;
+        }
+        if (value && typeof value === 'object') {
+            const out = {};
+            const origObj = original && typeof original === 'object' && !Array.isArray(original)
+                ? original
+                : {};
+            for (const [k, v] of Object.entries(value)) {
+                out[k] = normalizeByOrigin(v, origObj[k]);
+            }
+            return out;
+        }
+        return value;
+    };
+    const normalizedArgs = normalizeByOrigin(interpolatedArgs, op.args);
+    const containsLiteral = (v) => {
+        if (typeof v === 'string') {
+            return LITERAL_RE.test(v) || GLOBAL_RE.test(v);
+        }
+        if (Array.isArray(v))
+            return v.some(containsLiteral);
+        if (v && typeof v === 'object') {
+            for (const val of Object.values(v)) {
+                if (containsLiteral(val))
+                    return true;
+            }
+        }
+        return false;
+    };
+    if (containsLiteral(normalizedArgs)) {
+        throw new Error('Unresolved literals remain in interpolated args');
+    }
+    return { ...op, args: normalizedArgs };
+}

package/dist/NodeManager/node/task/globalStore/resolveLiteralsInString.d.ts

@@ -0,0 +1,2 @@
+import TaskManager from '../TaskManager.js';
+export declare function resolveLiteralsInString(this: TaskManager, input: string): string;

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

@@ -0,0 +1,7 @@
+export function resolveLiteralsInString(input) {
+    const LITERAL_RE = /%%ops\.([^.]+)\.([%A-Za-z0-9._-]+)%%/g;
+    return input.replace(LITERAL_RE, (_m, opId, path) => {
+        const value = this.getByPath(opId, path);
+        return value == null ? '' : String(value);
+    });
+}

package/dist/NodeManager/node/task/globalStore/setDefaults.d.ts

@@ -0,0 +1,4 @@
+import { JobDefinition } from '@nosana/sdk';
+import TaskManager from '../TaskManager.js';
+export declare function setDefaults(this: TaskManager, flowId: string, project: string, jobDefinition: JobDefinition): void;
+export declare function rehydrateEndpointsForOperation(this: TaskManager, flowId: string, project: string, jobDefinition: JobDefinition, opId: string): void;

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

@@ -0,0 +1,65 @@
+import { createHash, isOperator, isSpreadMarker, } from '@nosana/sdk';
+import { configs } from '../../../configs/configs.js';
+import { NodeConfigsSingleton } from '../../../configs/NodeConfigs.js';
+import { generateExposeId } from '../../../utils/expose-util.js';
+export function setDefaults(flowId, project, jobDefinition) {
+    if (jobDefinition.global?.variables) {
+        this.globalOpStore.variables = {
+            ...this.globalOpStore.variables,
+            ...jobDefinition.global.variables,
+        };
+        this.globalStore.variables = {
+            ...this.globalStore.variables,
+            ...jobDefinition.global.variables,
+        };
+    }
+    processOperationsForEndpoints.call(this, flowId, project, jobDefinition, jobDefinition.ops);
+}
+export function rehydrateEndpointsForOperation(flowId, project, jobDefinition, opId) {
+    const op = jobDefinition.ops.find((o) => o.id === opId);
+    if (!op)
+        return;
+    processOperationsForEndpoints.call(this, flowId, project, jobDefinition, [
+        op,
+    ]);
+}
+function processOperationsForEndpoints(flowId, project, jobDefinition, ops) {
+    const config = NodeConfigsSingleton.getInstance();
+    for (const op of ops) {
+        const index = jobDefinition.ops.findIndex((o) => o.id === op.id);
+        if (op.type === 'container/run') {
+            const { args } = op;
+            if (args.expose) {
+                const opStore = (this.globalOpStore[op.id] ??= {});
+                if (!opStore.endpoint) {
+                    opStore.endpoint = {};
+                }
+                if (Array.isArray(args.expose)) {
+                    for (const exposedPort of args.expose) {
+                        if (isSpreadMarker(exposedPort))
+                            continue; // skip dynamic
+                        if (typeof exposedPort === 'string' && isOperator(exposedPort))
+                            continue;
+                        const p = typeof exposedPort === 'object'
+                            ? exposedPort.port
+                            : exposedPort;
+                        opStore.endpoint[`${p}`] = `${generateExposeId(flowId, index, p, args.private)}.${configs().frp.serverAddr}`;
+                    }
+                }
+                else {
+                    if (!isSpreadMarker(args.expose) &&
+                        !(typeof args.expose === 'string' && isOperator(args.expose))) {
+                        opStore.endpoint[`${args.expose}`] = `${generateExposeId(flowId, index, args.expose, args.private)}.${configs().frp.serverAddr}`;
+                    }
+                }
+                if (jobDefinition.deployment_id) {
+                    opStore.deployment_endpoint = `${generateExposeId(
+                    // @ts-ignore
+                    config.options.isNodeRun
+                        ? jobDefinition.deployment_id
+                        : createHash(`${jobDefinition.deployment_id}:${project}`, 45), op.id, 0, false)}.${configs().frp.serverAddr}`;
+                }
+            }
+        }
+    }
+}

package/dist/NodeManager/node/task/globalStore/setHost.d.ts

@@ -0,0 +1,2 @@
+import TaskManager from '../TaskManager.js';
+export declare function setHost(this: TaskManager, opId: string, flowId: string): void;

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

@@ -0,0 +1,9 @@
+export function setHost(opId, flowId) {
+    const op = (this.globalOpStore[opId] ??= {});
+    op.host = flowId + '-' + this.getOpStateIndex(opId);
+    // Host updated; attempt endpoint rehydration for this op
+    const flow = this.repository.getFlow(this.job);
+    if (flow) {
+        this.rehydrateEndpointsForOperation(flow.id, flow.project, flow.jobDefinition, opId);
+    }
+}

package/dist/NodeManager/node/task/globalStore/setResult.d.ts

@@ -0,0 +1,2 @@
+import TaskManager from '../TaskManager.js';
+export declare function setResult(this: TaskManager, opId: string, key: string, value: any): void;

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

@@ -0,0 +1,10 @@
+export function setResult(opId, key, value) {
+    const op = (this.globalOpStore[opId] ??= {});
+    const results = (op.results ??= {});
+    results[key] = value;
+    // Now that results changed for opId, rehydrate any non-dynamic endpoints for this op
+    const flow = this.repository.getFlow(this.job);
+    if (flow) {
+        this.rehydrateEndpointsForOperation(flow.id, flow.project, flow.jobDefinition, opId);
+    }
+}

package/dist/NodeManager/node/task/globalStore/setResults.d.ts

@@ -0,0 +1,2 @@
+import TaskManager from '../TaskManager.js';
+export declare function setResults(this: TaskManager, opId: string, values: Record<string, any>): void;

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

@@ -0,0 +1,9 @@
+export function setResults(opId, values) {
+    const op = (this.globalOpStore[opId] ??= {});
+    op.results = { ...(op.results ?? {}), ...values };
+    // Results updated for opId; attempt endpoint rehydration for this op
+    const flow = this.repository.getFlow(this.job);
+    if (flow) {
+        this.rehydrateEndpointsForOperation(flow.id, flow.project, flow.jobDefinition, opId);
+    }
+}

package/dist/NodeManager/node/task/globalStore/stanatizeArrays.d.ts

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

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

@@ -0,0 +1,14 @@
+export function stanatizeArrays(op) {
+    for (const [key, value] of Object.entries(op.args)) {
+        if (Array.isArray(value)) {
+            const indexOfEmptyOpArg = value.findIndex((v) => v === '__remove-if-empty__');
+            if (indexOfEmptyOpArg !== -1) {
+                value.splice(indexOfEmptyOpArg, 1);
+                if (value.length === 0) {
+                    delete op.args[key];
+                }
+            }
+        }
+    }
+    return op;
+}

package/dist/NodeManager/node/task/globalStore/transformCollections.d.ts

@@ -0,0 +1,13 @@
+import { Operation, OperationType } from '@nosana/sdk';
+import TaskManager from '../TaskManager.js';
+type JSONValue = string | number | boolean | null | JSONValue[] | {
+    [k: string]: JSONValue;
+};
+interface MarkerSpec {
+    key: string;
+    arrayHandler?: (raw: JSONValue, chunked: boolean) => JSONValue[];
+    objectHandler?: (raw: JSONValue) => Record<string, JSONValue>;
+}
+export declare const DefaultCollectionMarkers: MarkerSpec[];
+export declare function transformCollections<T extends OperationType>(this: TaskManager, op: Operation<T>, overwrite?: boolean): Operation<T>;
+export {};