@nosana/node 1.0.1 → 1.0.3-rc

package/dist/NodeManager/configs/__tests__/NodeConfigs.spec.js

@@ -1,161 +0,0 @@
-import { describe, expect, it, beforeEach, afterEach, vi } from 'vitest';
-import dotenv from 'dotenv';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-// Read .env files directly to avoid duplicating values
-const modulePath = path.dirname(fileURLToPath(import.meta.url));
-const envBase = dotenv.parse(fs.readFileSync(path.resolve(modulePath, '../../../../.env')));
-const envDev = dotenv.parse(fs.readFileSync(path.resolve(modulePath, '../../../../.env.dev')));
-const envProd = dotenv.parse(fs.readFileSync(path.resolve(modulePath, '../../../../.env.prd')));
-// Test constants for env variable names
-const ENV_VAR_BACKEND_SOLANA_ADDRESS = 'BACKEND_SOLANA_ADDRESS';
-const ENV_VAR_BACKEND_URL = 'BACKEND_URL';
-const ENV_VAR_MIN_DISK_SPACE = 'MIN_DISK_SPACE';
-const DEVNET = 'devnet';
-const MAINNET = 'mainnet';
-describe('NodeConfigs', () => {
-    let originalEnv;
-    beforeEach(() => {
-        originalEnv = { ...process.env };
-        vi.resetModules();
-        // Clear all relevant env vars to ensure clean state
-        delete process.env.APP_ENV;
-        delete process.env.NODE_ENV;
-        delete process.env.BACKEND_URL;
-        delete process.env.BACKEND_SOLANA_ADDRESS;
-        delete process.env.BACKEND_AUTHORIZATION_ADDRESS;
-        delete process.env.EXPLORER_URL;
-        delete process.env.SIGN_MESSAGE;
-        delete process.env.FRP_SERVER_ADDRESS;
-        delete process.env.FRP_SERVER_PORT;
-        delete process.env.FRPC_CONTAINER_IMAGE;
-        delete process.env.FRP_SERVER_IMAGE;
-        delete process.env.API_PORT;
-        delete process.env.MIN_DISK_SPACE;
-    });
-    afterEach(() => {
-        process.env = originalEnv;
-    });
-    describe('dotenv file merging', () => {
-        it('should load common variables from base .env file', async () => {
-            const { NodeConfigs } = await import('../NodeConfigs.js');
-            const nodeConfigs = new NodeConfigs({ network: MAINNET });
-            nodeConfigs.loadVariablesToEnv();
-            expect(process.env[ENV_VAR_BACKEND_SOLANA_ADDRESS]).toBe(envBase[ENV_VAR_BACKEND_SOLANA_ADDRESS]);
-        });
-        it('should load environment-specific variables', async () => {
-            const { NodeConfigs } = await import('../NodeConfigs.js');
-            const nodeConfigs = new NodeConfigs({ network: DEVNET });
-            nodeConfigs.loadVariablesToEnv();
-            expect(process.env[ENV_VAR_BACKEND_URL]).toBe(envDev[ENV_VAR_BACKEND_URL]);
-        });
-        it('should override common values with environment-specific values', async () => {
-            const { NodeConfigs } = await import('../NodeConfigs.js');
-            const nodeConfigs = new NodeConfigs({ network: DEVNET });
-            nodeConfigs.loadVariablesToEnv();
-            // MIN_DISK_SPACE exists in both .env (base) and .env.dev
-            // With override:true and env-specific file loaded last, development value should win
-            expect(process.env[ENV_VAR_MIN_DISK_SPACE]).toBe(envDev[ENV_VAR_MIN_DISK_SPACE]);
-        });
-        it('should use common value when environment-specific file does not override it', async () => {
-            const { NodeConfigs } = await import('../NodeConfigs.js');
-            const nodeConfigs = new NodeConfigs({ network: MAINNET });
-            nodeConfigs.loadVariablesToEnv();
-            // MIN_DISK_SPACE only has override in .env.dev, not in .env.prd
-            // So production should use the base .env value
-            expect(process.env[ENV_VAR_MIN_DISK_SPACE]).toBe(envBase[ENV_VAR_MIN_DISK_SPACE]);
-        });
-    });
-    describe('network to environment mapping', () => {
-        it('should use prd environment for mainnet network', async () => {
-            const { NodeConfigs } = await import('../NodeConfigs.js');
-            const nodeConfigs = new NodeConfigs({ network: MAINNET });
-            nodeConfigs.loadVariablesToEnv();
-            expect(process.env[ENV_VAR_BACKEND_URL]).toBe(envProd[ENV_VAR_BACKEND_URL]);
-        });
-        it('should use dev environment for devnet network', async () => {
-            const { NodeConfigs } = await import('../NodeConfigs.js');
-            const nodeConfigs = new NodeConfigs({ network: DEVNET });
-            nodeConfigs.loadVariablesToEnv();
-            expect(process.env[ENV_VAR_BACKEND_URL]).toBe(envDev[ENV_VAR_BACKEND_URL]);
-        });
-        it('should use dev environment when network is not mainnet', async () => {
-            const { NodeConfigs } = await import('../NodeConfigs.js');
-            const nodeConfigs = new NodeConfigs({ network: 'testnet' });
-            nodeConfigs.loadVariablesToEnv();
-            expect(process.env[ENV_VAR_BACKEND_URL]).toBe(envDev[ENV_VAR_BACKEND_URL]);
-        });
-        it('should default to mainnet (prd) when network is not specified', async () => {
-            const { NodeConfigs } = await import('../NodeConfigs.js');
-            const nodeConfigs = new NodeConfigs({});
-            nodeConfigs.loadVariablesToEnv();
-            expect(process.env[ENV_VAR_BACKEND_URL]).toBe(envProd[ENV_VAR_BACKEND_URL]);
-        });
-    });
-    describe('NodeConfigsSingleton', () => {
-        it('should only call loadVariablesToEnv once across multiple getInstance calls', async () => {
-            const { NodeConfigsSingleton, NodeConfigs } = await import('../NodeConfigs.js');
-            const loadSpy = vi.spyOn(NodeConfigs.prototype, 'loadVariablesToEnv');
-            NodeConfigsSingleton.getInstance({ network: DEVNET });
-            NodeConfigsSingleton.getInstance({ network: MAINNET });
-            NodeConfigsSingleton.getInstance();
-            expect(loadSpy).toHaveBeenCalledTimes(1);
-        });
-        it('should use options from first getInstance call', async () => {
-            const { NodeConfigsSingleton } = await import('../NodeConfigs.js');
-            // First call with devnet
-            NodeConfigsSingleton.getInstance({ network: DEVNET });
-            // Subsequent calls with different options should not change the config
-            NodeConfigsSingleton.getInstance({ network: MAINNET });
-            // Should still have dev environment values from first call
-            expect(process.env[ENV_VAR_BACKEND_URL]).toBe(envDev[ENV_VAR_BACKEND_URL]);
-        });
-    });
-    describe('startup without exceptions', () => {
-        it('should load configs for mainnet without throwing when all required variables have defaults', async () => {
-            // Clear all config-related environment variables to test defaults
-            delete process.env.APP_ENV;
-            delete process.env.NODE_ENV;
-            delete process.env.BACKEND_URL;
-            delete process.env.BACKEND_SOLANA_ADDRESS;
-            delete process.env.BACKEND_AUTHORIZATION_ADDRESS;
-            delete process.env.EXPLORER_URL;
-            delete process.env.SIGN_MESSAGE;
-            delete process.env.FRP_SERVER_ADDRESS;
-            delete process.env.FRP_SERVER_PORT;
-            delete process.env.FRPC_CONTAINER_IMAGE;
-            delete process.env.FRP_SERVER_IMAGE;
-            delete process.env.API_PORT;
-            delete process.env.MIN_DISK_SPACE;
-            // Attempt to load configs - should not throw
-            const { configs } = await import('../configs.js');
-            const config = configs({ network: MAINNET });
-            // Verify config object exists and has expected properties
-            expect(config).toBeDefined();
-            expect(config.network).toBe(MAINNET);
-        });
-        it('should load configs for devnet without throwing when all required variables have defaults', async () => {
-            // Clear all config-related environment variables to test defaults
-            delete process.env.APP_ENV;
-            delete process.env.NODE_ENV;
-            delete process.env.BACKEND_URL;
-            delete process.env.BACKEND_SOLANA_ADDRESS;
-            delete process.env.BACKEND_AUTHORIZATION_ADDRESS;
-            delete process.env.EXPLORER_URL;
-            delete process.env.SIGN_MESSAGE;
-            delete process.env.FRP_SERVER_ADDRESS;
-            delete process.env.FRP_SERVER_PORT;
-            delete process.env.FRPC_CONTAINER_IMAGE;
-            delete process.env.FRP_SERVER_IMAGE;
-            delete process.env.API_PORT;
-            delete process.env.MIN_DISK_SPACE;
-            // Attempt to load configs - should not throw
-            const { configs } = await import('../configs.js');
-            const config = configs({ network: DEVNET });
-            // Verify config object exists and has expected properties
-            expect(config).toBeDefined();
-            expect(config.network).toBe(DEVNET);
-        });
-    });
-});

package/dist/NodeManager/db/__tests__/index.spec.d.ts

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

package/dist/NodeManager/db/__tests__/index.spec.js

@@ -1,65 +0,0 @@
-import fs from 'fs';
-import { DB } from '../index.js';
-vi.mock('fs');
-vi.mock('os', () => ({
-    default: {
-        homedir: () => 'homedir',
-    },
-}));
-vi.mock('../../../static/index.js', () => ({
-    pkg: {
-        version: '0.0.0_TEST',
-    },
-}));
-describe('DB', () => {
-    const mock_mkdirSync = vi.fn();
-    beforeEach(() => {
-        fs.mkdirSync.mockImplementation((args1, args2) => mock_mkdirSync(args1, args2));
-    });
-    afterEach(() => {
-        mock_mkdirSync.mockReset();
-    });
-    it('should create db directory and return a DB instance', () => {
-        const result = new DB('test');
-        expect(mock_mkdirSync).toHaveBeenCalledTimes(1);
-        expect(mock_mkdirSync).toHaveBeenCalledWith('test', { recursive: true });
-        expect(result.db.data).toEqual({
-            resources: {
-                images: {},
-                volumes: {},
-            },
-            flows: {},
-            info: {
-                version: '0.0.0_TEST',
-                country: '',
-                network: {
-                    ip: '',
-                    ping_ms: 0,
-                    download_mbps: 0,
-                    upload_mbps: 0,
-                },
-                system_environment: '',
-                cpu: {
-                    model: '',
-                    physical_cores: 0,
-                    logical_cores: 0,
-                },
-                disk_gb: 0,
-                ram_mb: 0,
-                gpus: {
-                    devices: [],
-                    runtime_version: 0,
-                    cuda_driver_version: 0,
-                    nvml_driver_version: '0.0.0',
-                },
-                protocol: '',
-            },
-        });
-    });
-    test('when configLocation starts with ~ should replace with os.homedir', () => {
-        new DB('~/test');
-        expect(mock_mkdirSync).toHaveBeenCalledWith('homedir/test', {
-            recursive: true,
-        });
-    });
-});

package/dist/NodeManager/provider/__tests__/Provider.spec.d.ts

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

package/dist/NodeManager/provider/__tests__/Provider.spec.js

@@ -1,337 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { Provider } from '../Provider.js';
-import { isOpExposed, getExposePorts } from '@nosana/sdk';
-import { generateProxies } from '../../utils/expose-util.js';
-import EventEmitter from 'events';
-const TEST_SERVER_ADDRESS = 'test.frp.server.com';
-const TEST_SERVER_PORT = 7000;
-const TEST_FRPC_IMAGE = 'test-frpc-image:latest';
-vi.mock('../../configs/configs.js', () => ({
-    configs: () => ({
-        frp: {
-            serverAddr: TEST_SERVER_ADDRESS,
-            serverPort: TEST_SERVER_PORT,
-            containerImage: TEST_FRPC_IMAGE,
-        },
-    }),
-}));
-vi.mock('../../configs/NodeConfigs.js', () => ({
-    NodeConfigsSingleton: {
-        getInstance: vi.fn().mockReturnValue({ options: { isNodeRun: false } }),
-    },
-}));
-vi.mock('../../monitoring/proxy/loggingProxy.js', () => ({
-    applyLoggingProxyToClass: vi.fn(),
-}));
-vi.mock('@nosana/sdk', async () => {
-    const actual = await vi.importActual('@nosana/sdk');
-    return {
-        ...actual,
-        isOpExposed: vi.fn(),
-        getExposePorts: vi.fn().mockReturnValue([]),
-    };
-});
-vi.mock('../../utils/expose-util.js', () => ({
-    generateProxies: vi.fn().mockReturnValue({ proxies: [], idMap: new Map() }),
-    generateUrlSecretObject: vi.fn().mockReturnValue({}),
-}));
-vi.mock('../../utils/timeoutPromiseWrapper.js', () => ({
-    promiseTimeoutWrapper: vi.fn((promise) => promise),
-}));
-const TEST_CONTAINER_ID = 'container-id';
-const TEST_CONTAINER_NAME = 'container-name';
-const TEST_FRPC_CONTAINER_NAME = `frpc-${TEST_CONTAINER_NAME}`;
-const TEST_FLOW_ID = 'flow-123';
-const TEST_DEPLOYMENT_HASH = 'deployment-hash-456';
-const TEST_DEPLOYMENT_ID = 'my-deployment-id';
-const TEST_PROXY_NAME_1 = 'proxy-1';
-const TEST_CONTAINER_NAME_1 = 'container-1';
-const TEST_CONTAINER_PORT_1 = '8080';
-const TEST_CUSTOM_DOMAIN_1 = 'test1.domain.com';
-const TEST_PROXY_NAME_2 = 'proxy-2';
-const TEST_CONTAINER_NAME_2 = 'container-2';
-const TEST_CONTAINER_PORT_2 = '3000';
-const TEST_CUSTOM_DOMAIN_2 = 'test2.domain.com';
-const TEST_CUSTOM_FLOW_ID = 'custom-flow-id-789';
-const TEST_API_PORT = '12345';
-const TEST_ADDRESS = 'test-address';
-const TEST_JOB_DEFINITION_TYPE = 'container';
-const TEST_JOB_DEFINITION_VERSION = '0.1';
-const TEST_PROJECT = 'test-project';
-const TEST_STATE_RUNNING = 'running';
-const TEST_NOW = Date.now();
-const TEST_OP_ID = 'op-1';
-const TEST_OP_TYPE = 'container/run';
-const TEST_OP_CONTAINER_IMAGE = 'test-image:latest';
-describe('Provider', () => {
-    let provider;
-    let mockContainerOrchestration;
-    let mockRepository;
-    let mockResourceManager;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockContainerOrchestration = {
-            pullImage: vi.fn().mockResolvedValue(undefined),
-            runFlowContainer: vi.fn().mockResolvedValue({
-                id: TEST_CONTAINER_ID,
-                logs: vi.fn().mockResolvedValue({
-                    on: vi.fn(),
-                    removeAllListeners: vi.fn(),
-                }),
-                wait: vi.fn().mockResolvedValue(undefined),
-                inspect: vi.fn().mockResolvedValue({ State: { ExitCode: 0 } }),
-            }),
-            doesContainerExist: vi.fn().mockResolvedValue(false),
-            isContainerExited: vi.fn().mockResolvedValue(false),
-            stopAndDeleteContainer: vi.fn().mockResolvedValue(undefined),
-            createNetwork: vi.fn().mockResolvedValue(undefined),
-            deleteNetwork: vi.fn().mockResolvedValue(undefined),
-            hasNetwork: vi.fn().mockResolvedValue(false),
-            getContainer: vi.fn().mockReturnValue({
-                id: TEST_CONTAINER_ID,
-                logs: vi.fn().mockResolvedValue({
-                    on: vi.fn(),
-                    removeAllListeners: vi.fn(),
-                }),
-                wait: vi.fn().mockResolvedValue(undefined),
-                inspect: vi.fn().mockResolvedValue({ State: { ExitCode: 0 } }),
-            }),
-            getContainersByName: vi.fn().mockResolvedValue([]),
-        };
-        mockRepository = {
-            updateflowStateSecret: vi.fn(),
-            getFlowSecret: vi.fn().mockReturnValue({}),
-        };
-        mockResourceManager = {
-            images: {
-                setImage: vi.fn(),
-            },
-            getResourceVolumes: vi.fn().mockResolvedValue([]),
-        };
-        provider = new Provider(mockContainerOrchestration, mockRepository, mockResourceManager);
-    });
-    describe('generateFrpcContainerConfig', () => {
-        const baseFlow = {
-            id: TEST_FLOW_ID,
-            jobDefinition: {
-                version: TEST_JOB_DEFINITION_VERSION,
-                type: TEST_JOB_DEFINITION_TYPE,
-                ops: [],
-            },
-            project: TEST_PROJECT,
-            state: {
-                status: TEST_STATE_RUNNING,
-                startTime: TEST_NOW,
-                endTime: null,
-                opStates: [],
-            },
-        };
-        const baseNetworks = { 'network-1': {} };
-        const baseProxies = [
-            {
-                name: TEST_PROXY_NAME_1,
-                localIp: TEST_CONTAINER_NAME_1,
-                localPorts: TEST_CONTAINER_PORT_1,
-                customDomain: TEST_CUSTOM_DOMAIN_1,
-            },
-        ];
-        it('should generate basic config without load balancing', () => {
-            const result = provider.generateFrpcContainerConfig(TEST_CONTAINER_NAME, baseNetworks, baseFlow, baseProxies, false, undefined);
-            expect(result).toStrictEqual({
-                name: TEST_FRPC_CONTAINER_NAME,
-                cmd: ['/entrypoint.sh'],
-                networks: baseNetworks,
-                requires_network_mode: true,
-                env: {
-                    FRP_SERVER_ADDR: TEST_SERVER_ADDRESS,
-                    FRP_SERVER_PORT: TEST_SERVER_PORT.toString(),
-                    NOSANA_ID: TEST_FLOW_ID,
-                    FRP_PROXIES: JSON.stringify(baseProxies),
-                    DEPLOYMENT_ID: '',
-                    JOB_ID: TEST_FLOW_ID,
-                },
-            });
-        });
-        it('should not include FRP_LB_GROUP_KEY when load balancing is disabled', () => {
-            const result = provider.generateFrpcContainerConfig(TEST_CONTAINER_NAME, baseNetworks, baseFlow, baseProxies, false, undefined);
-            expect(result.env).not.toHaveProperty('FRP_LB_GROUP_KEY');
-        });
-        it('should include FRP_LB_GROUP_KEY when load balancing is enabled', () => {
-            const result = provider.generateFrpcContainerConfig(TEST_CONTAINER_NAME, baseNetworks, baseFlow, baseProxies, true, TEST_DEPLOYMENT_HASH);
-            expect(result.env.FRP_LB_GROUP_KEY).toBe(TEST_DEPLOYMENT_HASH);
-        });
-        it('should set DEPLOYMENT_ID from flow.jobDefinition.deployment_id when present', () => {
-            const flowWithDeployment = {
-                ...baseFlow,
-                jobDefinition: {
-                    ...baseFlow.jobDefinition,
-                    deployment_id: TEST_DEPLOYMENT_ID,
-                },
-            };
-            const result = provider.generateFrpcContainerConfig(TEST_CONTAINER_NAME, baseNetworks, flowWithDeployment, baseProxies, false, undefined);
-            expect(result.env.DEPLOYMENT_ID).toBe(TEST_DEPLOYMENT_ID);
-        });
-        it('should set DEPLOYMENT_ID to empty string when deployment_id is not present', () => {
-            const result = provider.generateFrpcContainerConfig(TEST_CONTAINER_NAME, baseNetworks, baseFlow, baseProxies, false, undefined);
-            expect(result.env.DEPLOYMENT_ID).toBe('');
-        });
-        it('should serialize proxies array to JSON string', () => {
-            const multipleProxies = [
-                {
-                    name: TEST_PROXY_NAME_1,
-                    localIp: TEST_CONTAINER_NAME_1,
-                    localPorts: TEST_CONTAINER_PORT_1,
-                    customDomain: TEST_CUSTOM_DOMAIN_1,
-                },
-                {
-                    name: TEST_PROXY_NAME_2,
-                    localIp: TEST_CONTAINER_NAME_2,
-                    localPorts: TEST_CONTAINER_PORT_2,
-                    customDomain: TEST_CUSTOM_DOMAIN_2,
-                },
-            ];
-            const result = provider.generateFrpcContainerConfig(TEST_CONTAINER_NAME, baseNetworks, baseFlow, multipleProxies, false, undefined);
-            expect(result.env.FRP_PROXIES).toBe(JSON.stringify(multipleProxies));
-            expect(JSON.parse(result.env.FRP_PROXIES)).toStrictEqual(multipleProxies);
-        });
-        it('should use flow.id for both NOSANA_ID and JOB_ID', () => {
-            const flowWithCustomId = {
-                ...baseFlow,
-                id: TEST_CUSTOM_FLOW_ID,
-            };
-            const result = provider.generateFrpcContainerConfig(TEST_CONTAINER_NAME, baseNetworks, flowWithCustomId, baseProxies, false, undefined);
-            expect(result.env.NOSANA_ID).toBe(TEST_CUSTOM_FLOW_ID);
-            expect(result.env.JOB_ID).toBe(TEST_CUSTOM_FLOW_ID);
-        });
-        it('should prefix container name with frpc-', () => {
-            const result = provider.generateFrpcContainerConfig(TEST_CONTAINER_NAME, baseNetworks, baseFlow, baseProxies, false, undefined);
-            expect(result.name).toBe(TEST_FRPC_CONTAINER_NAME);
-        });
-        it('should pass networks through unchanged', () => {
-            const customNetworks = {
-                'network-a': {},
-                'network-b': {},
-            };
-            const result = provider.generateFrpcContainerConfig(TEST_CONTAINER_NAME, customNetworks, baseFlow, baseProxies, false, undefined);
-            expect(result.networks).toBe(customNetworks);
-        });
-    });
-    describe('setUpReverseProxyApi', () => {
-        const testAddress = TEST_ADDRESS;
-        it('should pull the frpcImage', async () => {
-            await provider.setUpReverseProxyApi(testAddress, TEST_API_PORT);
-            expect(mockContainerOrchestration.pullImage).toHaveBeenCalledWith(TEST_FRPC_IMAGE, undefined, expect.any(AbortController));
-        });
-        it('should register frpcImage with resource manager', async () => {
-            await provider.setUpReverseProxyApi(testAddress, TEST_API_PORT);
-            expect(mockResourceManager.images.setImage).toHaveBeenCalledWith(TEST_FRPC_IMAGE);
-        });
-        it('should run frpc container with frpcImage when container does not exist', async () => {
-            mockContainerOrchestration.doesContainerExist.mockResolvedValue(false);
-            await provider.setUpReverseProxyApi(testAddress, TEST_API_PORT);
-            const runFlowContainerCalls = mockContainerOrchestration.runFlowContainer.mock.calls;
-            const frpcContainerCall = runFlowContainerCalls.find((call) => call[0] === TEST_FRPC_IMAGE);
-            expect(frpcContainerCall).toBeDefined();
-            expect(frpcContainerCall[0]).toBe(TEST_FRPC_IMAGE);
-        });
-        it('should run frpc container with frpcImage when container has exited', async () => {
-            mockContainerOrchestration.doesContainerExist.mockResolvedValueOnce(true); // frpc check
-            mockContainerOrchestration.isContainerExited.mockResolvedValue(true);
-            await provider.setUpReverseProxyApi(testAddress, TEST_API_PORT);
-            const runFlowContainerCalls = mockContainerOrchestration.runFlowContainer.mock.calls;
-            const frpcContainerCall = runFlowContainerCalls.find((call) => call[0] === TEST_FRPC_IMAGE);
-            expect(frpcContainerCall).toBeDefined();
-            expect(frpcContainerCall[0]).toBe(TEST_FRPC_IMAGE);
-        });
-    });
-    describe('taskManagerContainerRunOperation', () => {
-        const baseFlow = {
-            id: TEST_FLOW_ID,
-            jobDefinition: {
-                version: TEST_JOB_DEFINITION_VERSION,
-                type: TEST_JOB_DEFINITION_TYPE,
-                ops: [
-                    {
-                        id: TEST_OP_ID,
-                        type: TEST_OP_TYPE,
-                        args: {
-                            image: TEST_OP_CONTAINER_IMAGE,
-                        },
-                    },
-                ],
-            },
-            project: TEST_PROJECT,
-            state: {
-                status: TEST_STATE_RUNNING,
-                startTime: TEST_NOW,
-                endTime: null,
-                opStates: [],
-            },
-        };
-        const baseOp = {
-            id: TEST_OP_ID,
-            type: TEST_OP_TYPE,
-            args: {
-                image: TEST_OP_CONTAINER_IMAGE,
-            },
-        };
-        describe('when operation is exposed', () => {
-            beforeEach(() => {
-                isOpExposed.mockReturnValue(true);
-                getExposePorts.mockReturnValue([
-                    // @ts-ignore
-                    { port: parseInt(TEST_CONTAINER_PORT_1), type: 'http' },
-                ]);
-                generateProxies.mockReturnValue({
-                    proxies: [],
-                    idMap: new Map(),
-                });
-            });
-            it('should pull the frpcImage', async () => {
-                const emitter = new EventEmitter();
-                const controller = new AbortController();
-                const operationPromise = provider.taskManagerContainerRunOperation(baseFlow, baseOp, controller, emitter);
-                await operationPromise;
-                expect(mockContainerOrchestration.pullImage).toHaveBeenCalledWith(TEST_FRPC_IMAGE, undefined, controller);
-            });
-            it('should register frpcImage with resource manager', async () => {
-                const emitter = new EventEmitter();
-                const controller = new AbortController();
-                const operationPromise = provider.taskManagerContainerRunOperation(baseFlow, baseOp, controller, emitter);
-                await operationPromise;
-                expect(mockResourceManager.images.setImage).toHaveBeenCalledWith(TEST_FRPC_IMAGE);
-            });
-            it('should run frpc container with frpcImage', async () => {
-                const emitter = new EventEmitter();
-                const controller = new AbortController();
-                const operationPromise = provider.taskManagerContainerRunOperation(baseFlow, baseOp, controller, emitter);
-                await operationPromise;
-                const runFlowContainerCalls = mockContainerOrchestration.runFlowContainer.mock.calls;
-                const frpcContainerCall = runFlowContainerCalls.find((call) => call[0] === TEST_FRPC_IMAGE);
-                expect(frpcContainerCall).toBeDefined();
-                expect(frpcContainerCall[0]).toBe(TEST_FRPC_IMAGE);
-            });
-        });
-        describe('when operation is NOT exposed', () => {
-            beforeEach(() => {
-                isOpExposed.mockReturnValue(false);
-                getExposePorts.mockReturnValue([]);
-            });
-            it('should NOT pull or use frpcImage', async () => {
-                const emitter = new EventEmitter();
-                const controller = new AbortController();
-                const operationPromise = provider.taskManagerContainerRunOperation(baseFlow, baseOp, controller, emitter);
-                await operationPromise;
-                const pullImageCalls = mockContainerOrchestration.pullImage.mock.calls;
-                const frpcPullCall = pullImageCalls.find((call) => call[0] === TEST_FRPC_IMAGE);
-                expect(frpcPullCall).toBeUndefined();
-                const setImageCalls = mockResourceManager.images.setImage.mock.calls;
-                const frpcSetImageCall = setImageCalls.find((call) => call[0] === TEST_FRPC_IMAGE);
-                expect(frpcSetImageCall).toBeUndefined();
-                const runFlowContainerCalls = mockContainerOrchestration.runFlowContainer.mock.calls;
-                const frpcContainerCall = runFlowContainerCalls.find((call) => call[0] === TEST_FRPC_IMAGE);
-                expect(frpcContainerCall).toBeUndefined();
-            });
-        });
-    });
-});

package/dist/NodeManager/provider/containerOrchestration/selectContainerOrchestration.js

@@ -1,11 +0,0 @@
-import { DockerContainerOrchestration } from './docker/index.js';
-import { PodmanContainerOrchestration } from './podman/index.js';
-export function selectContainerOrchestrationProvider(provider, url, gpu) {
-    switch (provider) {
-        case 'podman':
-            return new PodmanContainerOrchestration(url, gpu);
-        case 'docker':
-        default:
-            return new DockerContainerOrchestration(url, gpu);
-    }
-}

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

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

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

@@ -1,33 +0,0 @@
-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/commands/run/__tests__/command.spec.d.ts

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

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

@@ -1,37 +0,0 @@
-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 6 options', () => {
-        expect(runNodeCommand.options.length).toBe(6);
-    });
-    it.each([
-        ['--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/commands/start/__tests__/command.spec.d.ts

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