@nosana/node 1.0.0-rc

package/dist/NodeManager/utils/jobDefinitionParser.js

@@ -0,0 +1,31 @@
+import fs from 'fs';
+import path from 'path';
+import { parse as parseYaml, stringify as toYaml } from 'yaml';
+/**
+ * Converts a YAML string to a JSON-compatible object.
+ */
+export function yamlToJson(yamlString) {
+    return parseYaml(yamlString);
+}
+/**
+ * Converts a JSON-compatible object to a YAML string.
+ */
+export function jsonToYaml(obj) {
+    return toYaml(obj);
+}
+/**
+ * Loads a job definition file (YAML or JSON) and returns the parsed object.
+ */
+export function loadJobDefinitionFromFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    if (ext === '.yaml' || ext === '.yml') {
+        return yamlToJson(raw);
+    }
+    else if (ext === '.json') {
+        return JSON.parse(raw);
+    }
+    else {
+        throw new Error(`Unsupported file extension: ${ext}. Expected .json, .yaml or .yml`);
+    }
+}

package/dist/NodeManager/utils/ops-util.d.ts

@@ -0,0 +1,3 @@
+import type { JobDefinition } from '@nosana/sdk';
+export declare const isPrivate: (job: JobDefinition) => boolean;
+export declare const isExposed: (job: JobDefinition) => boolean;

package/dist/NodeManager/utils/ops-util.js

@@ -0,0 +1,19 @@
+export const isPrivate = (job) => {
+    return job.ops.some((op) => {
+        if (op.type !== 'container/run')
+            return false;
+        const args = op.args;
+        const expose = args.expose;
+        const isExposed = (Array.isArray(expose) && expose.length > 0) ||
+            typeof expose === 'number';
+        return isExposed && args.private === true;
+    });
+};
+export const isExposed = (job) => {
+    return job.ops.some((op) => {
+        if (op.type !== 'container/run')
+            return false;
+        const expose = op.args.expose;
+        return ((Array.isArray(expose) && expose.length > 0) || typeof expose === 'number');
+    });
+};

package/dist/NodeManager/utils/timeoutPromiseWrapper.d.ts

@@ -0,0 +1 @@
+export declare function promiseTimeoutWrapper<T extends unknown>(promise: Promise<T>, expiry_time: number, abortController: AbortController): Promise<T>;

package/dist/NodeManager/utils/timeoutPromiseWrapper.js

@@ -0,0 +1,27 @@
+export function promiseTimeoutWrapper(promise, expiry_time, abortController) {
+    const timeoutError = new Error('Promise took too long to settle, expiry timeout met.');
+    const timer = setTimeout(() => {
+        abortController.abort();
+    }, expiry_time * 1000);
+    if (abortController.signal.aborted) {
+        return Promise.reject(timeoutError);
+    }
+    return new Promise((resolve, reject) => {
+        const onSettled = () => {
+            clearTimeout(timer);
+            abortController.signal.removeEventListener('abort', abortHandler);
+        };
+        const abortHandler = () => {
+            onSettled();
+            reject(timeoutError);
+        };
+        abortController.signal.addEventListener('abort', abortHandler);
+        promise
+            .then((value) => resolve(value))
+            .catch((error) => {
+            abortController.abort();
+            reject(error);
+        })
+            .finally(onSettled);
+    });
+}

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

@@ -0,0 +1,39 @@
+/**
+ * Method to pause the process
+ * @param seconds Number of seconds to pause
+ */
+declare const sleep: (seconds: number) => Promise<void>;
+/**
+ * Method to easily get a universal timestamp
+ */
+declare const now: () => number;
+declare function askYesNoQuestion(question: string, onYes: () => Promise<void>, onNo: () => void): Promise<void>;
+declare const clearLine: () => void;
+declare const colors: {
+    RED: string;
+    GREEN: string;
+    YELLOW: string;
+    BLUE: string;
+    CYAN: string;
+    WHITE: string;
+    RESET: string;
+};
+/**
+ * Method to test and cast strings into string arrays
+ * @param {string | string[]} value The string or string array being tested and casted
+ * @returns { string[] } Returns a string array
+ */
+declare const ifStringCastToArray: (value: string | string[]) => string[];
+declare function logTable(data: any): void;
+declare function isNodeOnboarded(status: string): boolean;
+declare const SECONDS_PER_DAY: number;
+export { logTable, now, sleep, clearLine, askYesNoQuestion, colors, ifStringCastToArray, SECONDS_PER_DAY, isNodeOnboarded, };
+/**
+ * Loads the configuration value for a given environment variable key.
+ * Throws an error at runtime if the environment variable is not set.
+ *
+ * @param {string} key - The name of the environment variable to retrieve.
+ * @return {string} The value of the specified environment variable.
+ * @throws {Error} If the environment variable is not defined.
+ */
+export declare function loadConfigurationValue(key: string): string;

package/dist/NodeManager/utils/utils.js

@@ -0,0 +1,107 @@
+import { Console } from 'console';
+import { Transform } from 'stream';
+import inquirer from 'inquirer';
+/**
+ * Method to pause the process
+ * @param seconds Number of seconds to pause
+ */
+const sleep = (seconds) => new Promise((res) => setTimeout(res, seconds * 1e3));
+/**
+ * Method to easily get a universal timestamp
+ */
+const now = () => Math.floor(Date.now() / 1e3);
+async function askYesNoQuestion(question, onYes, onNo) {
+    return inquirer
+        .prompt([
+        {
+            type: 'input',
+            name: 'confirm',
+            message: question,
+            default: 'y',
+            validate: (input) => {
+                const lowerInput = input.toLowerCase();
+                if (lowerInput === 'y' ||
+                    lowerInput === 'yes' ||
+                    lowerInput === 'n' ||
+                    lowerInput === 'no') {
+                    return true; // Valid input
+                }
+                return 'Please enter "y" or "yes" for yes or "n" or "no" for no.'; // Repeat question if invalid
+            },
+            filter: (input) => input.toLowerCase(), // Normalize input to lowercase
+        },
+    ])
+        .then((answers) => {
+        if (answers.confirm === 'y' || answers.confirm === 'yes') {
+            return onYes();
+        }
+        else {
+            onNo();
+        }
+    });
+}
+const clearLine = () => {
+    process.stdout.moveCursor(0, -1); // up one line
+    process.stdout.clearLine(1); // from cursor to end
+};
+const colors = {
+    RED: '\u001b[1;31m',
+    GREEN: '\u001b[1;32m',
+    YELLOW: '\u001b[1;33m',
+    BLUE: '\u001b[1;34m',
+    CYAN: '\u001b[1;36m',
+    WHITE: '\u001b[1;38;5;231m',
+    RESET: '\u001b[0m',
+};
+/**
+ * Method to test and cast strings into string arrays
+ * @param {string | string[]} value The string or string array being tested and casted
+ * @returns { string[] } Returns a string array
+ */
+const ifStringCastToArray = (value) => typeof value === 'string' ? [value] : value;
+function logTable(data) {
+    if (data && data.length > 0) {
+        const ts = new Transform({
+            transform(chunk, enc, cb) {
+                cb(null, chunk);
+            },
+        });
+        const logger = new Console({ stdout: ts });
+        logger.table(data);
+        const table = (ts.read() || '').toString();
+        let result = '';
+        for (let row of table.split(/[\r\n]+/)) {
+            let r = row.replace(/[^┬]*┬/, '┌');
+            r = r.replace(/^├─*┼/, '├');
+            r = r.replace(/│[^│]*/, '');
+            r = r.replace(/^└─*┴/, '└');
+            r = r.replace(/'/g, ' ');
+            result += `${r}\n`;
+        }
+        console.log(result);
+        clearLine();
+    }
+    else {
+        console.log('[]');
+    }
+}
+function isNodeOnboarded(status) {
+    return ['ONBOARDED', 'PREMIUM'].includes(status);
+}
+const SECONDS_PER_DAY = 24 * 60 * 60;
+export { logTable, now, sleep, clearLine, askYesNoQuestion, colors, ifStringCastToArray, SECONDS_PER_DAY, isNodeOnboarded, };
+/**
+ * Loads the configuration value for a given environment variable key.
+ * Throws an error at runtime if the environment variable is not set.
+ *
+ * @param {string} key - The name of the environment variable to retrieve.
+ * @return {string} The value of the specified environment variable.
+ * @throws {Error} If the environment variable is not defined.
+ */
+export function loadConfigurationValue(key) {
+    let value = process.env[key];
+    if (!value) {
+        throw new Error(`Missing environment variable ${key}`);
+    }
+    return value;
+}

package/dist/NodeManager/utils/wslCheck.d.ts

@@ -0,0 +1,14 @@
+export declare function isWSLHost(systemEnvironment: string): boolean;
+export declare function isWSLBlockActive(): boolean;
+export declare function displayWSLWarning(): void;
+export declare function displayWSLBlockMessage(): void;
+export declare class WSLBlockedError extends Error {
+    constructor();
+}
+/**
+ * Check WSL status and handle warning/blocking
+ *
+ * @param systemEnvironment - The system_environment value from specs
+ * @throws WSLBlockedError if WSL host and block date has passed
+ */
+export declare function checkWSLStatus(systemEnvironment: string): void;

package/dist/NodeManager/utils/wslCheck.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+const WSL_QUEUE_BLOCK_DATE = new Date('2025-12-15T00:00:00Z');
+export function isWSLHost(systemEnvironment) {
+    if (!systemEnvironment)
+        return false;
+    return systemEnvironment.toLowerCase().includes('wsl');
+}
+export function isWSLBlockActive() {
+    return new Date() >= WSL_QUEUE_BLOCK_DATE;
+}
+export function displayWSLWarning() {
+    console.log('');
+    console.log(chalk.bgYellow.black.bold(' ⚠️  WSL DEPRECATION WARNING '));
+    console.log('');
+    console.log(chalk.yellow('WSL hosts are being removed from the Nosana network.'));
+    console.log('');
+    console.log(chalk.yellow(`• ${chalk.bold('December 15, 2025')}: WSL hosts will be blocked from joining the queue`));
+    console.log(chalk.yellow(`• ${chalk.bold('January 15, 2026')}: Premium market keys for WSL hosts will be revoked`));
+    console.log('');
+    console.log(chalk.yellow('Please migrate to a native Linux installation to continue participating in the network.'));
+    console.log('');
+}
+export function displayWSLBlockMessage() {
+    console.log('');
+    console.log(chalk.bgRed.white.bold(' 🚫 WSL HOST BLOCKED '));
+    console.log('');
+    console.log(chalk.red(`WSL hosts have been blocked from the queue since ${chalk.bold('December 15, 2025')}.`));
+    console.log(chalk.red(`Premium market keys for WSL hosts will be revoked on ${chalk.bold('January 15, 2026')}.`));
+    console.log('');
+    console.log(chalk.red('Please migrate to a native Linux installation to continue participating in the network.'));
+    console.log('');
+}
+export class WSLBlockedError extends Error {
+    constructor() {
+        super('WSL hosts are no longer allowed to join the queue');
+        this.name = 'WSLBlockedError';
+    }
+}
+/**
+ * Check WSL status and handle warning/blocking
+ *
+ * @param systemEnvironment - The system_environment value from specs
+ * @throws WSLBlockedError if WSL host and block date has passed
+ */
+export function checkWSLStatus(systemEnvironment) {
+    if (!isWSLHost(systemEnvironment)) {
+        return;
+    }
+    if (isWSLBlockActive()) {
+        displayWSLBlockMessage();
+        throw new WSLBlockedError();
+    }
+    displayWSLWarning();
+}

package/dist/cli/address/__tests__/command.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/address/__tests__/command.spec.js

@@ -0,0 +1,33 @@
+import { addressCommand } from '../command';
+import { getAddress } from '../action';
+vi.mock('../action', () => ({
+    getAddress: vi.fn(),
+}));
+describe('addressCommand', () => {
+    const mock_getAddress_action = vi.fn();
+    const parseArgs = ['node', 'get', 'run command'];
+    beforeEach(() => {
+        mock_getAddress_action.mockReset();
+        getAddress.mockImplementation(mock_getAddress_action);
+    });
+    it('should call run action', () => {
+        addressCommand.parse(parseArgs);
+        expect(mock_getAddress_action).toHaveBeenCalledTimes(1);
+    });
+    it('should set post job args', () => {
+        addressCommand.parse(parseArgs);
+        expect(addressCommand.args[0]).toBe('run command');
+    });
+    it('should have 2 options', () => {
+        expect(addressCommand.options.length).toBe(2);
+    });
+    it.each([
+        ['--network', '-n', 'mainnet'],
+        ['--wallet', '-w', '~/.nosana/nosana_key.json'],
+    ])('should have %s option', (long, short, defaultValue) => {
+        const option = addressCommand.options.find((i) => i.long === long);
+        expect(option?.long).toBe(long);
+        expect(option?.short).toBe(short);
+        expect(option?.defaultValue).toBe(defaultValue);
+    });
+});

package/dist/cli/address/action.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+export declare function getAddress(options: {
+    [key: string]: any;
+}, cmd: Command): Promise<void>;

package/dist/cli/address/action.js

@@ -0,0 +1,4 @@
+import { getSDK } from '../../NodeManager/sdk/index.js';
+export async function getAddress(options, cmd) {
+    const nosana = getSDK();
+}

package/dist/cli/address/command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const addressCommand: Command;

package/dist/cli/address/command.js

@@ -0,0 +1,9 @@
+import { program } from 'commander';
+import { getAddress } from './action.js';
+import { networkOption, walletOption } from '../sharedOptions/index.js';
+export const addressCommand = program
+    .command('address')
+    .description('Print your public key address')
+    .addOption(walletOption)
+    .addOption(networkOption)
+    .action(getAddress);

package/dist/cli/createNosanaCli.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const createNosanaCLI: (version: string) => Command;

package/dist/cli/createNosanaCli.js

@@ -0,0 +1,32 @@
+import { Command, Option } from 'commander';
+import { nodeCommand } from './node/index.js';
+import { addressCommand } from './address/command.js';
+import { OUTPUT_EVENTS } from '../output-formatter/outputEvents.js';
+import { outputFormatArgumentParser } from '../output-formatter/outputFormatArgumentParser.js';
+import { outputFormatSelector } from '../output-formatter/outputFormatSelector.js';
+import { setSDK } from '../NodeManager/sdk/index.js';
+import { configs } from '../NodeManager/configs/configs.js';
+import { NodeConfigsSingleton } from '../NodeManager/configs/NodeConfigs.js';
+export const createNosanaCLI = (version) => new Command()
+    .name('nosana-node')
+    .description('Nosana Node')
+    .version(version)
+    .configureHelp({ showGlobalOptions: true })
+    .hook('preSubcommand', async (_, actionCommand) => {
+    outputFormatSelector(outputFormatArgumentParser(actionCommand.parent?.args ?? [])).output(OUTPUT_EVENTS.OUTPUT_HEADER_LOGO, { text: 'Nosana' });
+})
+    .hook('preAction', async (command, actionCommand) => {
+    const opts = actionCommand.optsWithGlobals();
+    NodeConfigsSingleton.getInstance(opts);
+    let market = opts.market;
+    if (opts.network || opts.wallet) {
+        await setSDK(opts.network, opts.rpc, market, opts.wallet, actionCommand.opts());
+    }
+    const isNodeRun = command.args[0] === 'node' && command.args[1] === 'run';
+    configs({ ...opts, isNodeRun });
+})
+    .addOption(new Option('--log <logLevel>', 'Log level')
+    .default('debug')
+    .choices(['info', 'none', 'debug', 'trace']))
+    .addCommand(nodeCommand)
+    .addCommand(addressCommand);

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+export declare function startCLI(version: string): Promise<void>;

package/dist/cli/index.js

@@ -0,0 +1,16 @@
+import { createNosanaCLI } from './createNosanaCli.js';
+import { outputFormatSelector } from '../output-formatter/outputFormatSelector.js';
+import { validateCLIVersion } from '../version/index.js';
+export async function startCLI(version) {
+    const cli = createNosanaCLI(version);
+    try {
+        await validateCLIVersion();
+        await cli.parseAsync(process.argv);
+        outputFormatSelector('').finalize();
+    }
+    catch (e) {
+        outputFormatSelector('').finalize();
+        console.error(e);
+        process.exit(1);
+    }
+}

package/dist/cli/node/__tests__/index.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/node/__tests__/index.spec.js

@@ -0,0 +1,10 @@
+import { nodeCommand } from '../';
+describe('nodeCommand', () => {
+    it('should have only three commands', () => {
+        expect(nodeCommand.commands.length).toBe(3);
+    });
+    it.each([['run'], ['start'], ['prune']])('should contain %s command', (command) => {
+        // @ts-ignore
+        expect(nodeCommand.commands.map((command) => command._name)).toContain(command);
+    });
+});

package/dist/cli/node/index.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+export * from './run/command.js';
+export * from './start/command.js';
+export * from './prune/command.js';
+export declare const nodeCommand: Command;

package/dist/cli/node/index.js

@@ -0,0 +1,12 @@
+import { program } from 'commander';
+import { runNodeCommand } from './run/command.js';
+import { startNodeCommand } from './start/command.js';
+import { nodePruneCommand } from './prune/command.js';
+export * from './run/command.js';
+export * from './start/command.js';
+export * from './prune/command.js';
+export const nodeCommand = program
+    .command('node')
+    .addCommand(nodePruneCommand)
+    .addCommand(runNodeCommand)
+    .addCommand(startNodeCommand);

package/dist/cli/node/prune/action.d.ts

@@ -0,0 +1,4 @@
+export * from './action.js';
+export declare function pruneResources(options: {
+    [key: string]: any;
+}): Promise<void>;

package/dist/cli/node/prune/action.js

@@ -0,0 +1,18 @@
+import { DB } from '../../../NodeManager/db/index.js';
+import { ResourceManager } from '../../../NodeManager/node/resource/resourceManager.js';
+import { selectContainerOrchestrationProvider } from '../../../NodeManager/provider/containerOrchestration/selectContainerOrchestration.js';
+import { NodeRepository } from '../../../NodeManager/repository/NodeRepository.js';
+export * from './action.js';
+export async function pruneResources(options) {
+    try {
+        const db = new DB(options.config).db;
+        const repository = new NodeRepository(db);
+        const containerOrchestration = selectContainerOrchestrationProvider(options.provider, options.podman, options.gpu);
+        const resourceManager = new ResourceManager(containerOrchestration, repository);
+        await resourceManager.prune();
+        console.log('Finished pruning system');
+    }
+    catch (error) {
+        throw new Error(`Pruning system failed: ${error}`);
+    }
+}

package/dist/cli/node/prune/command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const nodePruneCommand: Command;

package/dist/cli/node/prune/command.js

@@ -0,0 +1,10 @@
+import { Command, Option } from 'commander';
+import { pruneResources } from './action.js';
+export const nodePruneCommand = new Command('prune')
+    .description('Safely prune none required images and resources.')
+    .addOption(new Option('--provider <provider>', 'provider used to run the job')
+    .choices(['docker', 'podman'])
+    .default('podman'))
+    .addOption(new Option('--docker, --podman <URI>', 'Podman/Docker connection URI').default('~/.nosana/podman/podman.sock'))
+    .addOption(new Option('-c, --config <path>', 'Config path (to store the flows database and other config)').default('~/.nosana/'))
+    .action(pruneResources);

package/dist/cli/node/run/__tests__/command.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/node/run/__tests__/command.spec.js

@@ -0,0 +1,38 @@
+import { runNodeCommand } from '../command';
+import { runJob } from '../action';
+vi.mock('../action', () => ({
+    runJob: vi.fn(),
+}));
+describe('runNodeCommand', () => {
+    const mock_run_job_action = vi.fn();
+    const parseArgs = ['node', 'run', 'job definition path'];
+    beforeEach(() => {
+        mock_run_job_action.mockReset();
+        runJob.mockImplementation(mock_run_job_action);
+    });
+    it('should call runJob action', () => {
+        runNodeCommand.parse(parseArgs);
+        expect(mock_run_job_action).toHaveBeenCalledTimes(1);
+    });
+    it('should set run job args', () => {
+        runNodeCommand.parse(parseArgs);
+        expect(runNodeCommand.args[0]).toBe('job definition path');
+    });
+    it('should have 7 options', () => {
+        expect(runNodeCommand.options.length).toBe(7);
+    });
+    it.each([
+        ['--provider', undefined, 'podman'],
+        ['--config', '-c', '~/.nosana/'],
+        ['--podman', '--docker', '~/.nosana/podman/podman.sock'],
+        ['--url', undefined, undefined],
+        ['--gpu', undefined, 'all'],
+        ['--verbose', undefined, undefined],
+        ['--wallet', '-w', '~/.nosana/nosana_key.json'],
+    ])('should have %s option', (long, short, defaultValue) => {
+        const option = runNodeCommand.options.find((i) => i.long === long);
+        expect(option?.long).toBe(long);
+        expect(option?.short).toBe(short);
+        expect(option?.defaultValue).toBe(defaultValue);
+    });
+});

package/dist/cli/node/run/action.d.ts

@@ -0,0 +1,3 @@
+export declare function runJob(jobDefinitionFile: string, options: {
+    [key: string]: any;
+}): Promise<void>;

package/dist/cli/node/run/action.js

@@ -0,0 +1,82 @@
+import util from 'util';
+import { createHash } from '@nosana/sdk';
+import { Provider } from '../../../NodeManager/provider/Provider.js';
+import { ResourceManager } from '../../../NodeManager/node/resource/resourceManager.js';
+import { NodeRepository } from '../../../NodeManager/repository/NodeRepository.js';
+import { DB } from '../../../NodeManager/db/index.js';
+import { selectContainerOrchestrationProvider } from '../../../NodeManager/provider/containerOrchestration/selectContainerOrchestration.js';
+import { log } from '../../../NodeManager/monitoring/log/NodeLog.js';
+import { ConsoleLogger } from '../../../NodeManager/monitoring/log/console/ConsoleLogger.js';
+import TaskManager, { StopReasons, } from '../../../NodeManager/node/task/TaskManager.js';
+import { loadJobDefinitionFromFile } from '../../../NodeManager/utils/jobDefinitionParser.js';
+import { generateDeploymentEndpointsTable } from './generateDeploymentEndpointsTable.js';
+import { generateRandomId } from '../../../NodeManager/node/utils/generateRandomId.js';
+import { getSDK } from '../../../NodeManager/sdk/index.js';
+import { createLoggingProxy } from '../../../NodeManager/monitoring/proxy/loggingProxy.js';
+export async function runJob(jobDefinitionFile, options) {
+    try {
+        const sdk = getSDK();
+        const jobDefinition = await resolveJobDefinition(options, jobDefinitionFile);
+        if (jobDefinition.deployment_id) {
+            jobDefinition.deployment_id = createHash(`local-${jobDefinition.deployment_id}:${sdk.solana.wallet.publicKey.toString()}`, 45);
+            generateDeploymentEndpointsTable(jobDefinition);
+        }
+        /**
+         * set up log listening, any instance can listen to log produces from the node
+         * the logs are produces from the log proxy
+         */
+        log();
+        const db = new DB(options.config).db;
+        const repository = createLoggingProxy(new NodeRepository(db));
+        const containerOrchestration = selectContainerOrchestrationProvider(options.provider, options.podman, options.gpu);
+        const resourceManager = new ResourceManager(containerOrchestration, repository);
+        const provider = new Provider(containerOrchestration, repository, resourceManager);
+        const logger = new ConsoleLogger(false);
+        logger.addObserver();
+        const job = generateRandomId(32);
+        const tm = new TaskManager(provider, repository, job, sdk.solana.wallet.publicKey.toString(), jobDefinition);
+        tm.bootstrap();
+        const exitHandler = async () => {
+            await tm.stop(StopReasons.STOPPED);
+        };
+        process.on('SIGINT', exitHandler); // Handle Ctrl+C
+        process.on('SIGTERM', exitHandler); // Handle termination signals
+        await tm.start();
+        const result = repository.getFlowState(job);
+        console.log('\nResult: ', util.inspect(result, { showHidden: false, depth: null, colors: true }));
+    }
+    catch (error) {
+        const formattedError = `
+      ========== ERROR ==========
+      Timestamp: ${new Date().toISOString()}
+      Error Name: ${error.name || 'Unknown Error'}
+      Message: ${error.message || 'No message available'}${options.verbose
+            ? `
+      Trace: ${error.stack ?? error.trace}`
+            : ''}
+      ============================
+      `;
+        console.error(formattedError);
+    }
+    process.exit();
+}
+async function resolveJobDefinition(options, jobDefinitionFile) {
+    let jobDefinition;
+    if (options.url) {
+        try {
+            const data = await fetch(options.url);
+            const json = await data.json();
+            jobDefinition = json;
+        }
+        catch (e) {
+            throw new Error(`Failed to fetch remote job flow.\n${e}`);
+        }
+    }
+    else {
+        if (!jobDefinitionFile) {
+            throw new Error('Missing Job Definition Argument');
+        }
+        jobDefinition = loadJobDefinitionFromFile(jobDefinitionFile);
+    }
+    return jobDefinition;
+}

package/dist/cli/node/run/command.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export * from './action.js';
+export declare const runNodeCommand: Command;