@nosana/node 1.0.0-rc

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

@@ -0,0 +1,17 @@
+import { Argument, Command, Option } from 'commander';
+import { runJob } from './action.js';
+import { gpuOption, verboseOption, walletOption } from '../../sharedOptions/index.js';
+export * from './action.js';
+export const runNodeCommand = new Command('run')
+    .description('Run Job Definition File')
+    .addArgument(new Argument('<job-definition-file>', 'Job Definition File').argOptional())
+    .addOption(new Option('--provider <provider>', 'provider used to run the job definition')
+    .choices(['docker', 'podman'])
+    .default('podman'))
+    .addOption(new Option('--url <url>', 'Url path for the JSON flow'))
+    .addOption(new Option('-c, --config <path>', 'Config path (to store the flows database and other config)').default('~/.nosana/'))
+    .addOption(new Option('--docker, --podman <URI>', 'Podman/Docker connection URI').default('~/.nosana/podman/podman.sock'))
+    .addOption(walletOption)
+    .addOption(gpuOption)
+    .addOption(verboseOption)
+    .action(runJob);

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

@@ -0,0 +1,2 @@
+import { JobDefinition } from '@nosana/sdk';
+export declare function generateDeploymentEndpointsTable(jobDefinition: JobDefinition): void;

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

@@ -0,0 +1,45 @@
+import { Table } from 'console-table-printer';
+import { isOperator, isSpreadMarker, } from '@nosana/sdk';
+import { generateExposeId } from '../../../NodeManager/utils/expose-util.js';
+import { configs } from '../../../NodeManager/configs/configs.js';
+export function generateDeploymentEndpointsTable(jobDefinition) {
+    const table = new Table({
+        title: `🚀 Deployment Endpoints 🚀`,
+        defaultColumnOptions: {
+            alignment: 'left',
+            color: 'green',
+        },
+    });
+    for (const op of jobDefinition.ops) {
+        if (op.type === 'container/run') {
+            const { expose } = op.args;
+            if (expose) {
+                if (typeof expose === 'number' ||
+                    (typeof expose === 'string' && !isOperator(expose))) {
+                    const generatedId = generateExposeId(jobDefinition.deployment_id, op.id, 0, false);
+                    table.addRow({
+                        OpId: op.id,
+                        Port: expose,
+                        Url: `https://${generatedId}.${configs().frp.serverAddr}`,
+                    });
+                }
+                if (Array.isArray(expose)) {
+                    expose.forEach((port) => {
+                        if (isSpreadMarker(port))
+                            return; // skip dynamic
+                        if (typeof port === 'string' && isOperator(port))
+                            return; // skip dynamic
+                        const p = typeof port === 'object' ? port.port : port;
+                        const generatedId = generateExposeId(jobDefinition.deployment_id, op.id, 0, false);
+                        table.addRow({
+                            OpId: op.id,
+                            Port: p,
+                            Url: `https://${generatedId}.${configs().frp.serverAddr}`,
+                        });
+                    });
+                }
+            }
+        }
+    }
+    table.printTable();
+}

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

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

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

@@ -0,0 +1,39 @@
+import { startNodeCommand } from '../command';
+import { startNode } from '../action';
+vi.mock('../action', () => ({
+    startNode: vi.fn(),
+}));
+describe('startNodeCommand', () => {
+    const mock_start_node_action = vi.fn();
+    const parseArgs = ['node', 'start', 'market address'];
+    beforeEach(() => {
+        mock_start_node_action.mockReset();
+        startNode.mockImplementation(mock_start_node_action);
+    });
+    it('should call startNode action', () => {
+        startNodeCommand.parse(parseArgs);
+        expect(mock_start_node_action).toHaveBeenCalledTimes(1);
+    });
+    it('should set start node args', () => {
+        startNodeCommand.parse(parseArgs);
+        expect(startNodeCommand.args[0]).toBe('market address');
+    });
+    it('should have 9 options', () => {
+        expect(startNodeCommand.options.length).toBe(9);
+    });
+    it.each([
+        ['--network', '-n', 'mainnet'],
+        ['--rpc', undefined, undefined],
+        ['--wallet', '-w', '~/.nosana/nosana_key.json'],
+        ['--provider', undefined, 'podman'],
+        ['--config', '-c', '~/.nosana/'],
+        ['--port', '-p', 5001],
+        ['--podman', '--docker', '~/.nosana/podman/podman.sock'],
+        ['--gpu', undefined, 'all'],
+    ])('should have %s option', (long, short, defaultValue) => {
+        const option = startNodeCommand.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/start/action.d.ts

@@ -0,0 +1,4 @@
+import 'rpc-websockets/dist/lib/client.js';
+export declare function startNode(market: string, options: {
+    [key: string]: any;
+}): Promise<void>;

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

@@ -0,0 +1,48 @@
+import 'rpc-websockets/dist/lib/client.js';
+import NodeManager from '../../../NodeManager/index.js';
+export async function startNode(market, options) {
+    const nodeManager = new NodeManager(options);
+    while (true) {
+        try {
+            await nodeManager.init();
+            await nodeManager.start(market);
+        }
+        catch (error) {
+            if (error.name === 'WSLBlockedError') {
+                await nodeManager.stop();
+                process.exit(1);
+            }
+            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);
+            console.error('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.error('Get support in our Discord Server. Join:');
+            console.error('https://nosana.com/discord');
+            console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+            if (error.name == 'NodeAlreadyActiveError') {
+                process.exit();
+            }
+            if (nodeManager.inJobLoop) {
+                try {
+                    await nodeManager.clean();
+                }
+                catch (error) { }
+                await nodeManager.delay(60);
+                continue;
+            }
+            else {
+                await nodeManager.error();
+                await nodeManager.stop();
+                process.exit();
+            }
+        }
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+import { Command, Option } from 'commander';
+import { startNode } from './action.js';
+import { networkOption, portOption, rpcOption, walletOption, verboseOption, gpuOption } from '../../sharedOptions/index.js';
+export * from './action.js';
+export const startNodeCommand = new Command('start')
+    .description('Start Nosana Node')
+    .argument('[market]', 'market address')
+    .addOption(networkOption)
+    .addOption(rpcOption)
+    .addOption(walletOption)
+    .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/'))
+    .addOption(gpuOption)
+    .addOption(portOption)
+    .addOption(verboseOption)
+    .action(startNode);

package/dist/cli/sharedOptions/--api.d.ts

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

package/dist/cli/sharedOptions/--api.js

@@ -0,0 +1,2 @@
+import { Option } from 'commander';
+export const apiOption = new Option('--api <api key>', 'set api key');

package/dist/cli/sharedOptions/--format.d.ts

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

package/dist/cli/sharedOptions/--format.js

@@ -0,0 +1,4 @@
+import { Option } from 'commander';
+export const formatOption = new Option('--format <type>', 'show result in the specified format')
+    .choices(['text', 'json'])
+    .default('text');

package/dist/cli/sharedOptions/--gpu.d.ts

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

package/dist/cli/sharedOptions/--gpu.js

@@ -0,0 +1,12 @@
+import chalk from 'chalk';
+import { InvalidOptionArgumentError, Option } from 'commander';
+function validateGPUOption(value) {
+    if (!value.match(new RegExp(/^\d+(,\d+)*$/)) && value !== 'all') {
+        throw new InvalidOptionArgumentError('Expected a comma seperated number list or "all"');
+    }
+    console.warn(chalk.yellow(`Setting GPU device ${value}, please ensure your nvidia-ctk is correctly configured to generate using device index naming strategy to avoid errors.`));
+    return value;
+}
+export const gpuOption = new Option('--gpu <gpus>', 'set gpu devices')
+    .argParser(validateGPUOption)
+    .default('all');

package/dist/cli/sharedOptions/--network.d.ts

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

package/dist/cli/sharedOptions/--network.js

@@ -0,0 +1,4 @@
+import { Option } from 'commander';
+export const networkOption = new Option('-n, --network <network>', 'network to run on')
+    .default('mainnet')
+    .choices(['devnet', 'mainnet']);

package/dist/cli/sharedOptions/--port.d.ts

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

package/dist/cli/sharedOptions/--port.js

@@ -0,0 +1,2 @@
+import { Option } from 'commander';
+export const portOption = new Option('-p, --port <api-port>', 'api port to run on').default(5001);

package/dist/cli/sharedOptions/--rpc.d.ts

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

package/dist/cli/sharedOptions/--rpc.js

@@ -0,0 +1,2 @@
+import { Option } from 'commander';
+export const rpcOption = new Option('--rpc <url>', 'RPC node to use');

package/dist/cli/sharedOptions/--timeout.d.ts

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

package/dist/cli/sharedOptions/--timeout.js

@@ -0,0 +1,12 @@
+import { Option } from 'commander';
+export const timeoutOption = new Option('-t, --timeout <timeout>', 'the duration you want to add to the job (in minutes)')
+    .makeOptionMandatory(true)
+    .argParser((value) => {
+    const timeout = parseInt(value, 10);
+    if (isNaN(timeout) || timeout <= 0) {
+        throw new Error('Invalid timeout value. Please provide a positive integer.');
+    }
+    // Convert minutes to seconds
+    const timeoutInSeconds = timeout * 60;
+    return timeoutInSeconds;
+});

package/dist/cli/sharedOptions/--verbose.d.ts

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

package/dist/cli/sharedOptions/--verbose.js

@@ -0,0 +1,2 @@
+import { Option } from 'commander';
+export const verboseOption = new Option('--verbose', 'show more detailed result').conflicts(['format']);

package/dist/cli/sharedOptions/--wallet.d.ts

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

package/dist/cli/sharedOptions/--wallet.js

@@ -0,0 +1,2 @@
+import { Option } from 'commander';
+export const walletOption = new Option('-w, --wallet <wallet>', 'path to wallet private key').default('~/.nosana/nosana_key.json');

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

@@ -0,0 +1,7 @@
+export * from './--network.js';
+export * from './--rpc.js';
+export * from './--wallet.js';
+export * from './--format.js';
+export * from './--port.js';
+export * from './--gpu.js';
+export * from './--verbose.js';

package/dist/cli/sharedOptions/index.js

@@ -0,0 +1,8 @@
+// istanbul ignore file
+export * from './--network.js';
+export * from './--rpc.js';
+export * from './--wallet.js';
+export * from './--format.js';
+export * from './--port.js';
+export * from './--gpu.js';
+export * from './--verbose.js';

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env -S node --no-warnings
+/// <reference path="../src/global.d.ts" />
+export * from './cli/node/index.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env -S node --no-warnings
+/// <reference path="./global.d.ts" />
+import { pkg } from './static/index.js';
+import { startCLI } from './cli/index.js';
+const VERSION = pkg.version;
+startCLI(VERSION);
+export * from './cli/node/index.js';

package/dist/output-formatter/OutputFormatter.d.ts

@@ -0,0 +1,61 @@
+import { OutputEvent, OutputEventParams } from './outputEvents.js';
+/**
+ * Interface defining the structure for output formatter adapters.
+ * Adapters implementing this interface should provide implementations
+ * for handling various output events and finalizing the output.
+ */
+export interface OutputFormatterAdapter {
+    finalize(): void;
+    output<T extends keyof OutputEventParams>(event: T, param: OutputEventParams[T]): void;
+}
+/**
+ * Class responsible for formatting output based on the provided adapter.
+ * The adapter can be either a JSON formatter or a Text formatter (and more can be added),
+ * depending on the user's choice.
+ */
+export declare class OutputFormatter {
+    private format;
+    constructor(format: OutputFormatterAdapter);
+    /**
+     * Outputs an event using the selected format.
+     * @param {OutputEvent} event - The event type to be output.
+     * @param {T} param - The parameters associated with the event.
+     *
+     * Usage:
+     *
+     * ```typescript
+     * // To get a JSON formatter
+     * const formatter = outputFormatSelector('json');
+     *
+     * // To output an event
+     * formatter.output(OUTPUT_EVENTS.EXAMPLE_OUTPUT, { log: { log: 'Job started\n' } });
+     * ```
+     */
+    output<T extends OutputEvent>(event: T, param: OutputEventParams[T]): void;
+    /**
+     * Throws an event using the selected format, typically used for error handling.
+     * Note: This method works similarly to `output`, but it indicates that an error has occurred.
+     * After every throw event, an actual error is thrown.
+     * @param {OutputEvent} event - The event type to be thrown.
+     * @param {T} param - The parameters associated with the event.
+     *
+     * Usage:
+     *
+     * ```typescript
+     * // To throw an event (usually for error handling)
+     * formatter.throw(OUTPUT_EVENTS.EXAMPLE_OUTPUT, { error: 'Invalid job definition' });
+     * ```
+     */
+    throw<T extends OutputEvent>(event: T, param: OutputEventParams[T]): void;
+    /**
+     * Finalizes the output, performing any necessary cleanup or final steps.
+     *
+     * Usage:
+     *
+     * ```typescript
+     * // Finalize the output (if needed)
+     * formatter.finalize();
+     * ```
+     */
+    finalize(): void;
+}

package/dist/output-formatter/OutputFormatter.js

@@ -0,0 +1,58 @@
+/**
+ * Class responsible for formatting output based on the provided adapter.
+ * The adapter can be either a JSON formatter or a Text formatter (and more can be added),
+ * depending on the user's choice.
+ */
+export class OutputFormatter {
+    constructor(format) {
+        this.format = format;
+    }
+    /**
+     * Outputs an event using the selected format.
+     * @param {OutputEvent} event - The event type to be output.
+     * @param {T} param - The parameters associated with the event.
+     *
+     * Usage:
+     *
+     * ```typescript
+     * // To get a JSON formatter
+     * const formatter = outputFormatSelector('json');
+     *
+     * // To output an event
+     * formatter.output(OUTPUT_EVENTS.EXAMPLE_OUTPUT, { log: { log: 'Job started\n' } });
+     * ```
+     */
+    output(event, param) {
+        this.format.output(event, param);
+    }
+    /**
+     * Throws an event using the selected format, typically used for error handling.
+     * Note: This method works similarly to `output`, but it indicates that an error has occurred.
+     * After every throw event, an actual error is thrown.
+     * @param {OutputEvent} event - The event type to be thrown.
+     * @param {T} param - The parameters associated with the event.
+     *
+     * Usage:
+     *
+     * ```typescript
+     * // To throw an event (usually for error handling)
+     * formatter.throw(OUTPUT_EVENTS.EXAMPLE_OUTPUT, { error: 'Invalid job definition' });
+     * ```
+     */
+    throw(event, param) {
+        this.format.output(event, param);
+    }
+    /**
+     * Finalizes the output, performing any necessary cleanup or final steps.
+     *
+     * Usage:
+     *
+     * ```typescript
+     * // Finalize the output (if needed)
+     * formatter.finalize();
+     * ```
+     */
+    finalize() {
+        this.format.finalize();
+    }
+}

package/dist/output-formatter/OutputFormatterFactory.d.ts

@@ -0,0 +1,4 @@
+import { OutputFormatter } from './OutputFormatter.js';
+export declare class OutputFormatterFactory {
+    static createFormatter(format: string): OutputFormatter;
+}

package/dist/output-formatter/OutputFormatterFactory.js

@@ -0,0 +1,18 @@
+import { JsonOutputFormatter } from './json/JsonOutputFormatter.js';
+import { OutputFormatter } from './OutputFormatter.js';
+import { TextOutputFormatter } from './text/TextOutputFormatter.js';
+import { VerboseTextOutputFormatter } from './text/VerboseTextOutputFormatter.js';
+export class OutputFormatterFactory {
+    static createFormatter(format) {
+        switch (format?.toLowerCase() ?? '') {
+            // add more formats here
+            case 'json':
+                return new OutputFormatter(new JsonOutputFormatter());
+            case 'verbose:text':
+                return new OutputFormatter(new VerboseTextOutputFormatter());
+            case 'text':
+            default:
+                return new OutputFormatter(new TextOutputFormatter());
+        }
+    }
+}

package/dist/output-formatter/__mocks__/outputEvents.mock.d.ts

@@ -0,0 +1,42 @@
+declare const outputEventsMock: {
+    READ_KEYFILE: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    EMPTY_KEYFILE: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    CREATE_KEYFILE: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_BALANCES: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_NETWORK: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_WALLET: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_IPFS_UPLOADED: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_SERVICE_URL: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_PRIVATE_URL_MESSAGE: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_URL: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JSON_FLOW_URL: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_MARKET_URL: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_PRICE: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_TOTAL_COST: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_STATUS: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_POSTING: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_POSTED_TX: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_VALIDATION_ERROR: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_POSTED_ERROR: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_SOL_BALANCE_LOW_ERROR: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_NOS_BALANCE_LOW_ERROR: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_AIRDROP_REQUEST_FAILED_ERROR: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_NOT_FOUND: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_CANNOT_LOG_RESULT: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR: import("@vitest/spy").Mock<(param: any) => never>;
+    OUTPUT_JSON_FLOW_TYPE_NOT_SUPPORTED_ERROR: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_NODE_URL: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_DURATION: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_START_TIME: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_RESULT_URL: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_EXECUTION: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_RETRIVE_JOB_COMMAND: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_FAILED_TO_FETCH_MARKETS_ERROR: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_HEADER_LOGO: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_URL_ERROR: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_URL_EXPIRED: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_URL_NOT_READY: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_INVALID: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+    OUTPUT_JOB_SERVICE_URL: import("@vitest/spy").Mock<import("@vitest/spy").Procedure>;
+};
+export default outputEventsMock;

package/dist/output-formatter/__mocks__/outputEvents.mock.js

@@ -0,0 +1,45 @@
+import { OUTPUT_EVENTS } from '../outputEvents.js';
+const outputEventsMock = {
+    [OUTPUT_EVENTS.READ_KEYFILE]: vi.fn(),
+    [OUTPUT_EVENTS.EMPTY_KEYFILE]: vi.fn(),
+    [OUTPUT_EVENTS.CREATE_KEYFILE]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_BALANCES]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_NETWORK]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_WALLET]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_IPFS_UPLOADED]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_SERVICE_URL]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_PRIVATE_URL_MESSAGE]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JSON_FLOW_URL]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_MARKET_URL]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_PRICE]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_TOTAL_COST]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_STATUS]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTING]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTED_TX]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_VALIDATION_ERROR]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTED_ERROR]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_SOL_BALANCE_LOW_ERROR]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_NOS_BALANCE_LOW_ERROR]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_AIRDROP_REQUEST_FAILED_ERROR]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_NOT_FOUND]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_CANNOT_LOG_RESULT]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR]: vi.fn((param) => {
+        throw param.error;
+    }),
+    [OUTPUT_EVENTS.OUTPUT_JSON_FLOW_TYPE_NOT_SUPPORTED_ERROR]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_NODE_URL]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_DURATION]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_START_TIME]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_RESULT_URL]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_EXECUTION]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_RETRIVE_JOB_COMMAND]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_FAILED_TO_FETCH_MARKETS_ERROR]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_HEADER_LOGO]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_ERROR]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_EXPIRED]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_NOT_READY]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_INVALID]: vi.fn(),
+    [OUTPUT_EVENTS.OUTPUT_JOB_SERVICE_URL]: vi.fn(),
+};
+export default outputEventsMock;

package/dist/output-formatter/__mocks__/outputFormatter.mock.js

@@ -0,0 +1,21 @@
+"use strict";
+vi.mock('../json/JsonOutputFormatter', () => {
+    return {
+        JsonOutputFormatter: vi.fn().mockImplementation(() => {
+            return {
+                finalize: vi.fn(),
+                output: vi.fn(),
+            };
+        }),
+    };
+});
+vi.mock('../text/TextOutputFormatter', () => {
+    return {
+        TextOutputFormatter: vi.fn().mockImplementation(() => {
+            return {
+                finalize: vi.fn(),
+                output: vi.fn(),
+            };
+        }),
+    };
+});

package/dist/output-formatter/__tests__/OutputFormatter.spec.d.ts

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

package/dist/output-formatter/__tests__/OutputFormatter.spec.js

@@ -0,0 +1,34 @@
+import { OutputFormatter } from '../OutputFormatter.js';
+import { OUTPUT_EVENTS } from '../outputEvents.js';
+class MockOutputFormatterAdapter {
+    constructor() {
+        this.finalize = vi.fn();
+        this.output = vi.fn();
+    }
+}
+describe('OutputFormatter', () => {
+    let formatter;
+    let mockAdapter;
+    beforeEach(() => {
+        mockAdapter = new MockOutputFormatterAdapter();
+        formatter = new OutputFormatter(mockAdapter);
+    });
+    it('should call the appropriate event handler', () => {
+        const param = {
+            job_url: 'http://example.com',
+        };
+        formatter.output(OUTPUT_EVENTS.OUTPUT_JOB_URL, param);
+        expect(mockAdapter.output).toHaveBeenCalledWith(OUTPUT_EVENTS.OUTPUT_JOB_URL, param);
+    });
+    it('should call the appropriate event handler for throw and throw error', () => {
+        const param = {
+            error: new Error('ARTIFACT NOT SUPPORT'),
+        };
+        formatter.throw(OUTPUT_EVENTS.OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR, param);
+        expect(mockAdapter.output).toHaveBeenCalledWith(OUTPUT_EVENTS.OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR, param);
+    });
+    it('should call finalize on the adapter', () => {
+        formatter.finalize();
+        expect(mockAdapter.finalize).toHaveBeenCalled();
+    });
+});

package/dist/output-formatter/__tests__/OutputFormatterFactory.spec.d.ts

@@ -0,0 +1 @@
+import '../__mocks__/outputFormatter.mock.js';