@nosana/node 1.0.0-rc

package/dist/NodeManager/provider/containerOrchestration/podman/utils/createPodmanRunOptions.js

@@ -0,0 +1,66 @@
+import { ifStringCastToArray } from '../../../../utils/utils.js';
+// These extra types are required because interface.ts
+function parseRestartPolicy(restart_policy) {
+    if (typeof restart_policy === 'string') {
+        return {
+            restart_policy: restart_policy === 'always' ? 'unless-stopped' : restart_policy,
+        };
+    }
+    if (typeof restart_policy === 'object' && 'policy' in restart_policy) {
+        return {
+            restart_policy: restart_policy.policy,
+            ...(restart_policy.restart_tries
+                ? { restart_tries: restart_policy.restart_tries }
+                : {}),
+        };
+    }
+    return {};
+}
+/**
+ * Takes image and args and return podman run options
+ * @param image
+ * @param args
+ * @param gpu
+ * @returns
+ */
+export function createPodmanRunOptions(image, args, gpuOption) {
+    const { name, cmd, gpu, volumes, env, aliases, work_dir, entrypoint, restart_policy, } = args;
+    const devices = gpu
+        ? gpuOption === 'all'
+            ? [
+                {
+                    path: 'nvidia.com/gpu=all',
+                },
+            ]
+            : gpuOption.split(',').map((id) => ({ path: `nvidia.com/gpu=${id}` }))
+        : [];
+    return {
+        image,
+        name,
+        command: cmd,
+        volumes: volumes?.map((v) => {
+            return {
+                dest: v.dest,
+                name: v.name,
+                Options: v.readonly ? ['ro'] : [],
+            };
+        }),
+        ...(entrypoint
+            ? { entrypoint: ifStringCastToArray(entrypoint) }
+            : undefined),
+        env,
+        devices,
+        ...parseRestartPolicy(restart_policy),
+        hostadd: [
+            'host.docker.internal:8.8.8.8',
+            'host.containers.internal:8.8.8.8',
+        ],
+        netns: { nsmode: 'bridge' },
+        Networks: {
+            NOSANA_GATEWAY: aliases ? { aliases } : {},
+        },
+        create_working_dir: true,
+        cgroups_mode: 'disabled',
+        work_dir,
+    };
+}

package/dist/NodeManager/provider/containerOrchestration/selectContainerOrchestration.d.ts

@@ -0,0 +1,2 @@
+import type { ContainerOrchestrationInterface } from './interface.js';
+export declare function selectContainerOrchestrationProvider(provider: string, url: string, gpu: string): ContainerOrchestrationInterface;

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

@@ -0,0 +1,11 @@
+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/NodeManager/provider/types.d.ts

@@ -0,0 +1,18 @@
+import { type Resource } from '@nosana/sdk';
+export type RequiredResource = Omit<Resource, 'target'>;
+export type StdOptions = 'stdin' | 'stdout' | 'stderr' | 'nodeerr';
+export type ReturnedStatus<T = undefined> = {
+    status: true;
+    result?: T;
+    error?: never;
+} | {
+    status: false;
+    error: Error | unknown;
+    result?: never;
+};
+export type HealthcheckPayload = {
+    id: string;
+    flowId: string;
+    port: number | string;
+    service?: string;
+};

package/dist/NodeManager/provider/types.js

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

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

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Log } from '@nosana/sdk';
+export declare function parseBuffer(buffer: Buffer, index?: number): Log;

package/dist/NodeManager/provider/utils/parseBuffer.js

@@ -0,0 +1,19 @@
+const TIMESTAMP_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})\s/;
+export function parseBuffer(buffer, index = 0) {
+    const head = buffer.subarray(index, (index += 8));
+    const chunkType = head.readUInt8(0);
+    const chunkLength = head.readUInt32BE(4);
+    const content = buffer.subarray(index, (index += chunkLength));
+    const rawLog = content.toString('utf-8');
+    const timestampMatch = rawLog.match(TIMESTAMP_REGEX);
+    const log = rawLog.replace(TIMESTAMP_REGEX, '');
+    let timestamp = new Date(Date.now()).toISOString();
+    if (timestampMatch) {
+        timestamp = timestampMatch[0].trim();
+    }
+    return {
+        log,
+        type: chunkType === 1 ? 'stdout' : 'stderr',
+        timestamp,
+    };
+}

package/dist/NodeManager/repository/NodeRepository.d.ts

@@ -0,0 +1,53 @@
+import type { LowSync } from 'lowdb';
+import type { Flow, OpState, FlowState } from '@nosana/sdk';
+import type { NodeDb, ResourceHistory, VolumeResource } from '../db/index.js';
+export declare class NodeRepository {
+    private db;
+    constructor(db: LowSync<NodeDb>);
+    getFlow(id: string): Flow;
+    getFlows(): {
+        [key: string]: Flow;
+    };
+    setflow(id: string, flow: Flow): void;
+    deleteflow(id: string): void;
+    addOpstate(id: string, opstate: OpState): void;
+    getFlowState(id: string): FlowState;
+    updateflowState(id: string, updatedFields: Partial<FlowState>): void;
+    updateflowStateSecret(id: string, updatedFields: {
+        [key: string]: any;
+    }): void;
+    getFlowSecret(id: string, key: string): any | undefined;
+    updateflowStateError(id: string, { status, error, }: {
+        status?: string;
+        error: Error | unknown;
+    }): void;
+    getOpState(id: string, index: number): OpState;
+    updateOpState(id: string, opIndex: number, updatedFields: Partial<OpState>): void;
+    updateOpStateExitCode(id: string, opIndex: number, exitCode: number): void;
+    updateOpStateLogs(id: string, opIndex: number, log: any): void;
+    setOpStateDiagnosticsReason(id: string, opIndex: number, reason: Partial<OpState['diagnostics']['reason']>): void;
+    setOpStateDiagnosticsState(id: string, opIndex: number, state: OpState['diagnostics']['state']): void;
+    updateOpStateError(id: string, opIndex: number, error: {
+        event: string;
+        message: string;
+        code?: number;
+    }): void;
+    updateNodeInfo(updatedFields: Partial<NodeDb['info']>): void;
+    getNodeInfo(): NodeDb['info'];
+    getImagesResources(): {
+        [key: string]: ResourceHistory;
+    };
+    getImageResource(image: string): ResourceHistory;
+    createImageResource(image: string, fields: ResourceHistory): void;
+    updateImageResource(image: string, updatedFields: Partial<ResourceHistory> | ResourceHistory): void;
+    deleteImageResource(image: string): void;
+    getVolumesResources(): {
+        [key: string]: VolumeResource;
+    };
+    getVolumeResource(volume: string): VolumeResource;
+    createVolumeResource(volume: string, fields: VolumeResource): void;
+    updateVolumeResource(volume: string, updatedFields: Partial<VolumeResource> | VolumeResource): void;
+    deleteVolumeResource(volume: string): void;
+    displayLog(log: string): string;
+    getFlowOperationName(id: string, index: number): string;
+}

package/dist/NodeManager/repository/NodeRepository.js

@@ -0,0 +1,153 @@
+const MAX_LOGS = 24999;
+export class NodeRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    getFlow(id) {
+        return this.db.data.flows[id];
+    }
+    getFlows() {
+        return this.db.data.flows;
+    }
+    setflow(id, flow) {
+        this.db.data.flows[id] = flow;
+        this.db.write();
+    }
+    deleteflow(id) {
+        delete this.db.data.flows[id];
+        this.db.write();
+    }
+    addOpstate(id, opstate) {
+        this.db.data.flows[id].state.opStates.push(opstate);
+        this.db.write();
+    }
+    getFlowState(id) {
+        return this.db.data.flows[id]?.state;
+    }
+    updateflowState(id, updatedFields) {
+        Object.assign(this.db.data.flows[id].state, updatedFields);
+        this.db.write();
+    }
+    updateflowStateSecret(id, updatedFields) {
+        if (!this.db.data.flows[id]?.state?.secrets) {
+            this.db.data.flows[id].state.secrets = {};
+        }
+        this.db.data.flows[id].state.secrets = {
+            ...this.db.data.flows[id].state.secrets,
+            ...updatedFields,
+        };
+        this.db.write();
+    }
+    getFlowSecret(id, key) {
+        const secrets = this.db.data.flows[id]?.state?.secrets ?? {};
+        return secrets[key];
+    }
+    updateflowStateError(id, { status, error, }) {
+        if (!this.db.data.flows[id]?.state)
+            throw new Error('Failed to find flow state.');
+        if (status) {
+            this.db.data.flows[id].state.status = status;
+        }
+        if (!this.db.data.flows[id].state.errors) {
+            this.db.data.flows[id].state.errors = [];
+        }
+        this.db.data.flows[id].state.errors.push(error instanceof Error ? error.message : error);
+        this.db.write();
+    }
+    getOpState(id, index) {
+        return this.db.data.flows[id].state.opStates[index];
+    }
+    updateOpState(id, opIndex, updatedFields) {
+        Object.assign(this.db.data.flows[id].state.opStates[opIndex], updatedFields);
+        this.db.write();
+    }
+    updateOpStateExitCode(id, opIndex, exitCode) {
+        this.db.data.flows[id].state.opStates[opIndex].exitCode = exitCode;
+        this.db.write();
+    }
+    updateOpStateLogs(id, opIndex, log) {
+        const logs = this.db.data.flows[id].state.opStates[opIndex].logs;
+        if (!logs) {
+            this.db.data.flows[id].state.opStates[opIndex].logs = [log];
+        }
+        else {
+            // Trim if already at max capacity
+            if (logs.length >= MAX_LOGS) {
+                logs.shift(); // Remove the oldest log
+            }
+            logs.push(log);
+        }
+        this.db.write();
+    }
+    setOpStateDiagnosticsReason(id, opIndex, reason) {
+        Object.assign(this.db.data.flows[id].state.opStates[opIndex].diagnostics.reason, reason);
+        this.db.write();
+    }
+    setOpStateDiagnosticsState(id, opIndex, state) {
+        this.db.data.flows[id].state.opStates[opIndex].diagnostics.state = state;
+        this.db.write();
+    }
+    updateOpStateError(id, opIndex, error) {
+        const opState = this.db.data.flows[id].state.opStates[opIndex];
+        opState.errors.push(error);
+        this.db.write();
+    }
+    updateNodeInfo(updatedFields) {
+        Object.assign(this.db.data.info, updatedFields);
+        this.db.write();
+    }
+    getNodeInfo() {
+        return this.db.data.info;
+    }
+    getImagesResources() {
+        return this.db.data.resources.images;
+    }
+    getImageResource(image) {
+        return this.db.data.resources.images[image];
+    }
+    createImageResource(image, fields) {
+        this.db.data.resources.images[image] = fields;
+        this.db.write();
+    }
+    updateImageResource(image, updatedFields) {
+        if (!this.db.data.resources.images[image]) {
+            this.createImageResource(image, updatedFields);
+        }
+        Object.assign(this.db.data.resources.images[image], updatedFields);
+        this.db.write();
+    }
+    deleteImageResource(image) {
+        delete this.db.data.resources.images[image];
+        this.db.write();
+    }
+    getVolumesResources() {
+        return this.db.data.resources.volumes;
+    }
+    getVolumeResource(volume) {
+        return this.db.data.resources.volumes[volume];
+    }
+    createVolumeResource(volume, fields) {
+        this.db.data.resources.volumes[volume] = fields;
+        this.db.write();
+    }
+    updateVolumeResource(volume, updatedFields) {
+        if (!this.db.data.resources.volumes[volume]) {
+            this.createVolumeResource(volume, updatedFields);
+        }
+        Object.assign(this.db.data.resources.volumes[volume], updatedFields);
+        this.db.write();
+    }
+    deleteVolumeResource(volume) {
+        delete this.db.data.resources.volumes[volume];
+        this.db.write();
+    }
+    displayLog(log) {
+        return log;
+    }
+    getFlowOperationName(id, index) {
+        if (this.db.data.flows[id]) {
+            return this.db.data.flows[id].jobDefinition.ops[index].id;
+        }
+        return 'null';
+    }
+}

package/dist/NodeManager/sdk/index.d.ts

@@ -0,0 +1,9 @@
+import { Client } from '@nosana/sdk';
+import 'rpc-websockets/dist/lib/client.js';
+import { TokenAmount, Transaction, VersionedTransaction } from '@solana/web3.js';
+import { OptionValues } from 'commander';
+export declare function setSDK(network: 'mainnet' | 'devnet', rpc: string | undefined, market: string | undefined, keyfile: string, options: OptionValues): Promise<Client>;
+export declare function getSDK(): Client<{}>;
+export declare function getNosBalance(): TokenAmount | undefined;
+export declare function getSolBalance(): number;
+export declare const getRawTransaction: (encodedTransaction: Uint8Array) => Promise<Transaction | VersionedTransaction>;

package/dist/NodeManager/sdk/index.js

@@ -0,0 +1,146 @@
+import fs from 'fs';
+import os from 'os';
+import chalk from 'chalk';
+import { Client } from '@nosana/sdk';
+import path from 'path';
+import 'rpc-websockets/dist/lib/client.js';
+import { Keypair, LAMPORTS_PER_SOL, Transaction, VersionedTransaction, } from '@solana/web3.js';
+import { colors } from '../utils/utils.js';
+import { OUTPUT_EVENTS } from '../../output-formatter/outputEvents.js';
+import { outputFormatSelector } from '../../output-formatter/outputFormatSelector.js';
+import { configs } from '../configs/configs.js';
+let nosana;
+let nosBalance, solBalance;
+export async function setSDK(network, rpc, market, keyfile, options) {
+    const envConfig = configs();
+    const formatter = outputFormatSelector(options.format);
+    const config = {
+        solana: {
+            priority_fee: 100000,
+        },
+    };
+    if (market)
+        config.solana.market_address = market;
+    if (options.api)
+        config.apiKey = options.api;
+    const createNewKeyPair = (filePath) => {
+        formatter.output(OUTPUT_EVENTS.CREATE_KEYFILE, { keyfile: keyfile });
+        const keypair = Keypair.generate();
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, JSON.stringify(Buffer.from(keypair.secretKey).toJSON().data));
+        return keypair;
+    };
+    let wallet = undefined;
+    if (keyfile) {
+        if (!process?.env?.SOLANA_WALLET) {
+            if (keyfile && keyfile[0] === '~') {
+                keyfile = keyfile.replace('~', os.homedir());
+            }
+            if (fs.existsSync(keyfile)) {
+                formatter.output(OUTPUT_EVENTS.READ_KEYFILE, { keyfile: keyfile });
+                const privateKey = fs.readFileSync(keyfile, 'utf8');
+                if (privateKey === '') {
+                    formatter.output(OUTPUT_EVENTS.EMPTY_KEYFILE, { keyfile: keyfile });
+                    const keypair = createNewKeyPair(keyfile);
+                    wallet = keypair;
+                }
+                else {
+                    wallet = privateKey;
+                }
+            }
+            else {
+                const keypair = createNewKeyPair(keyfile);
+                wallet = keypair;
+            }
+        }
+    }
+    if (rpc) {
+        config.solana.network = rpc;
+    }
+    nosana = new Client(network, wallet, config);
+    if (!rpc && network === 'mainnet' && wallet) {
+        // sign message for authentication
+        const signature = (await nosana.solana.signMessage(envConfig.signMessage));
+        const base64Signature = Buffer.from(signature).toString('base64');
+        const node = nosana.solana.wallet.publicKey.toString();
+        try {
+            const response = await fetch(`${envConfig.backendUrl}/rpc`, {
+                method: 'GET',
+                headers: {
+                    Authorization: `${node}:${base64Signature}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            const rpcFromBackend = await response.json();
+            if (response.status !== 200) {
+                console.log(chalk.yellow('Using default solana RPC. Some commands might not work, please provide your own with the --rpc option'));
+                // throw new Error(rpcFromBackend.message);
+            }
+            config.solana.network = rpcFromBackend.url;
+            nosana = new Client(network, wallet, config);
+        }
+        catch (e) {
+            console.log(chalk.yellow('Using default solana RPC. Some commands might not work, please provide your own with the --rpc option'));
+            // throw e;
+        }
+    }
+    if (network) {
+        formatter.output(OUTPUT_EVENTS.OUTPUT_NETWORK, { network });
+    }
+    if (keyfile) {
+        solBalance = await nosana.solana.getSolBalance();
+        nosBalance = await nosana.solana.getNosBalance();
+        formatter.output(OUTPUT_EVENTS.OUTPUT_WALLET, {
+            publicKey: nosana.solana.wallet.publicKey.toString(),
+        });
+        formatter.output(OUTPUT_EVENTS.OUTPUT_BALANCES, {
+            nos: nosBalance?.uiAmount?.toString() ?? '0',
+            sol: solBalance / LAMPORTS_PER_SOL,
+        });
+        if (options.airdrop &&
+            network.includes('devnet') &&
+            solBalance < 0.01 * LAMPORTS_PER_SOL
+        // || !nosBalance ||
+        // !nosBalance.uiAmount ||
+        // nosBalance.uiAmount < 1
+        ) {
+            console.log('\nNot enough SOL, requesting airdrop');
+            try {
+                // const airdropResult = await fetch(
+                //   `https://backend.k8s.dev.nos.ci/airdrop?address=${nosana.solana.wallet.publicKey.toString()}`,
+                // );
+                if (await nosana.solana.requestAirdrop(1e9)) {
+                    console.log(`Received airdrop of ${colors.CYAN}1 SOL!${colors.RESET}`);
+                }
+                else {
+                    formatter.throw(OUTPUT_EVENTS.OUTPUT_AIRDROP_REQUEST_FAILED_ERROR, {
+                        error: new Error('Airdrop Request Failed'),
+                    });
+                }
+            }
+            catch (error) {
+                formatter.throw(OUTPUT_EVENTS.OUTPUT_AIRDROP_REQUEST_FAILED_ERROR, {
+                    error: error,
+                });
+            }
+        }
+    }
+    return nosana;
+}
+export function getSDK() {
+    return nosana;
+}
+export function getNosBalance() {
+    return nosBalance;
+}
+export function getSolBalance() {
+    return solBalance;
+}
+export const getRawTransaction = async (encodedTransaction) => {
+    try {
+        return Transaction.from(encodedTransaction);
+    }
+    catch (error) {
+        return VersionedTransaction.deserialize(encodedTransaction);
+    }
+};

package/dist/NodeManager/types/index.d.ts

@@ -0,0 +1,27 @@
+export type CudaCheckResponse = CudaCheckSuccessResponse | CudaCheckErrorResponse;
+export type CudaCheckSuccessResponse = {
+    devices: {
+        index: number;
+        name: string;
+        uuid: string;
+        memory: {
+            total_mb: number;
+        };
+        network_architecture: {
+            major: number;
+            minor: number;
+        };
+        results: number[];
+    }[];
+    runtime_version: number;
+    cuda_driver_version: number;
+    nvml_driver_version: string;
+};
+export type CudaCheckErrorResponse = {
+    error: {
+        runtime_version: number;
+        is_cuda_available: boolean;
+        reason: string;
+        expection: string;
+    };
+};

package/dist/NodeManager/types/index.js

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

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

@@ -0,0 +1,4 @@
+export declare function convertFromBytes(bytes: number, toFormat?: 'gb' | 'mb' | 'kb'): {
+    value: number;
+    format: 'gb' | 'mb' | 'kb';
+};

package/dist/NodeManager/utils/convertFromBytes.js

@@ -0,0 +1,11 @@
+export function convertFromBytes(bytes, toFormat) {
+    let value = bytes / 1024;
+    if ((value < 1024 && !toFormat) || toFormat === 'kb') {
+        return { value: Number(value.toFixed(2)), format: 'kb' };
+    }
+    value = value / 1024;
+    if ((value < 1024 && !toFormat) || toFormat === 'mb') {
+        return { value: Number(value.toFixed(2)), format: 'mb' };
+    }
+    return { value: Number((value / 1024).toFixed(2)), format: 'gb' };
+}

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

@@ -0,0 +1,14 @@
+import { ExposedPort, Operation, JobDefinition } from '@nosana/sdk';
+export declare const generateExposeId: (flowId: string, op: number | string, port: number | string, isPrivate?: boolean) => string;
+export declare const getJobUrls: (job: JobDefinition, flowId: string) => string[];
+export declare function generateProxyConfig(generatedId: string, operationId: string | null, name: string, exposedPort: ExposedPort, op: Operation<'container/run'>, generatedDeploymentId: string | undefined, proxyHTTPHealthCheckPath: undefined | string): Object;
+export declare const generateProxies: (flowId: string, op: Operation<'container/run'>, opIndex: number, ports: ExposedPort[], name: string, operationId: string | null, deploymentId?: string | undefined) => {
+    proxies: Object[];
+    idMap: Map<string, ExposedPort>;
+};
+export declare const generateUrlSecretObject: (idMap: Map<string, ExposedPort>, operationId: string) => Record<string, {
+    opID: string;
+    port: number | string;
+    url: string;
+    status: 'ONLINE' | 'OFFLINE' | 'UNKNOWN';
+}>;

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

@@ -0,0 +1,88 @@
+import { randomBytes } from 'crypto';
+import { createHash, getExposeIdHash, getExposePorts, isOpExposed, } from '@nosana/sdk';
+import { isPrivate } from './ops-util.js';
+import { configs } from '../configs/configs.js';
+export const generateExposeId = (flowId, op, port, isPrivate) => {
+    const idLength = 45;
+    if (isPrivate) {
+        const randomData = randomBytes(45).toString('hex');
+        return createHash(randomData, idLength);
+    }
+    else {
+        return getExposeIdHash(flowId, op, port);
+    }
+};
+export const getJobUrls = (job, flowId) => {
+    const urls = [];
+    const privateMode = isPrivate(job);
+    if (privateMode) {
+        return ['private'];
+    }
+    Object.entries(job.ops).forEach(([, op], index) => {
+        if (isOpExposed(op)) {
+            const exposePorts = getExposePorts(op);
+            exposePorts.forEach((port) => {
+                const exposeId = getExposeIdHash(flowId, index, port.port);
+                const url = `${exposeId}.${configs().frp.serverAddr}`;
+                urls.push(url);
+            });
+        }
+    });
+    return urls;
+};
+export function generateProxyConfig(generatedId, operationId, name, exposedPort, op, generatedDeploymentId, proxyHTTPHealthCheckPath) {
+    return {
+        name: `${generatedId}-${operationId}`,
+        localIp: name,
+        localPorts: exposedPort.port.toString(),
+        opId: op.id,
+        customDomain: generatedId + '.' + configs().frp.serverAddr,
+        ...(generatedDeploymentId && {
+            deploymentDomain: generatedDeploymentId + '.' + configs().frp.serverAddr,
+            deploymentLoadBalancerGroup: `${generatedDeploymentId}-${exposedPort.port}`,
+            ...(exposedPort.health_checks && {
+                deploymentHealthCheckPath: proxyHTTPHealthCheckPath,
+            }),
+        }),
+    };
+}
+export const generateProxies = (flowId, op, opIndex, ports, name, operationId, deploymentId) => {
+    const proxies = [];
+    const idMap = new Map();
+    for (let exposedPort of ports) {
+        // TODO: use ids generated in the taskmanager to make secerts
+        const generatedId = generateExposeId(flowId, opIndex, exposedPort.port, op.args.private);
+        const generatedDeploymentId = deploymentId
+            ? generateExposeId(deploymentId, op.id, 0, false)
+            : undefined;
+        let proxyHTTPHealthCheckPath = undefined;
+        if (exposedPort.health_checks && exposedPort.health_checks.length > 0) {
+            const http_checks = exposedPort.health_checks.filter((healthCheck) => healthCheck.type === 'http' &&
+                healthCheck.method === 'GET' &&
+                healthCheck.expected_status === 200);
+            if (http_checks.length > 0) {
+                proxyHTTPHealthCheckPath = http_checks[0].path;
+            }
+        }
+        proxies.push(generateProxyConfig(generatedId, operationId, name, exposedPort, op, generatedDeploymentId, proxyHTTPHealthCheckPath));
+        idMap.set(generatedId, exposedPort);
+    }
+    return { proxies, idMap };
+};
+export const generateUrlSecretObject = (idMap, operationId) => Object.fromEntries(Array.from(idMap, ([id, exposedPort]) => {
+    const hasHealthChecks = Array.isArray(exposedPort.health_checks)
+        ? exposedPort.health_checks.length > 0
+        : false;
+    const initialStatus = hasHealthChecks
+        ? 'OFFLINE'
+        : 'UNKNOWN';
+    return [
+        id,
+        {
+            opID: operationId,
+            port: exposedPort.port,
+            url: `https://${id + '.' + configs().frp.serverAddr}`,
+            status: initialStatus,
+        },
+    ];
+}));

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

@@ -0,0 +1,12 @@
+/**
+ * Converts a YAML string to a JSON-compatible object.
+ */
+export declare function yamlToJson(yamlString: string): any;
+/**
+ * Converts a JSON-compatible object to a YAML string.
+ */
+export declare function jsonToYaml(obj: any): string;
+/**
+ * Loads a job definition file (YAML or JSON) and returns the parsed object.
+ */
+export declare function loadJobDefinitionFromFile(filePath: string): any;