@nosana/node 1.0.0-rc

package/dist/NodeManager/node/api/ApiHandler.js

@@ -0,0 +1,193 @@
+import cors from 'cors';
+import WebSocket from 'ws';
+import express from 'express';
+import ApiEventEmitter from './ApiEventEmitter.js';
+import { configs } from '../../configs/configs.js';
+import { sleep } from '../../utils/utils.js';
+import { stateStreaming } from '../../monitoring/streaming/StateStreamer.js';
+import { applyLoggingProxyToClass } from '../../monitoring/proxy/loggingProxy.js';
+import { verifyBackendSignatureMiddleware, verifyJobOwnerSignatureMiddleware, verifyWSJobOwnerSignatureMiddleware, verifyWSMiddleware, verifyWSNodeOrJobOwnerSignatureMiddleware, } from './middlewares/index.js';
+import { getNodeInfoRoute, getJobResultsRoute, getServiceUrlRoute, postJobDefinitionRoute, postServiceStopRoute, postNodeValidation, wssLogRoute, wssStatusRoute, getCurrentGroupStatusHandler, getGroupStatusHandler, getOperationsStatusHandler, getOperationStatusHandler, restartGroupOperationHandler, restartOperationHandler, stopGroupOperationHandler, stopOperationHandler, wssTaskManagerLogRoute, moveGroupOperationHandler, getJobDefinitionRoute, getJobInfoRoute, } from './routes/index.js';
+import { NodeAlreadyActiveError } from '../../errors/NodeAlreadyActiveError.js';
+export class ApiHandler {
+    constructor(sdk, repository, provider, port) {
+        this.sdk = sdk;
+        this.repository = repository;
+        this.provider = provider;
+        this.port = port;
+        this.server = null;
+        this.wss = null; // WebSocket server
+        this.eventEmitter = ApiEventEmitter.getInstance();
+        this.apiCheckInterval = null;
+        this.address = this.sdk.solana.provider.wallet.publicKey;
+        this.api = express();
+        this.api.use(cors());
+        this.registerRoutes();
+        applyLoggingProxyToClass(this);
+        // periodically check if the api server returns a response on / (the response is the address)
+        // if not stop the reverse proxy and set it up again
+    }
+    async start() {
+        try {
+            const server = await this.restartApiProxy();
+            return server;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async preventMultipleApiStarts() {
+        if (await this.testApiServerOnce(`https://${this.address}.${configs().frp.serverAddr}`)) {
+            throw new NodeAlreadyActiveError(this.address.toString());
+        }
+    }
+    async testApiServerOnce(server) {
+        try {
+            const response = await fetch(`${server}`);
+            if (!response.ok)
+                return false;
+            const responseText = await response.json();
+            return responseText === this.address.toString();
+        }
+        catch {
+            return false;
+        }
+    }
+    async restartApiProxy() {
+        await this.stopApiProxy();
+        await this.provider.setUpReverseProxyApi(this.address.toString(), this.port.toString());
+        this.stopServerAndWebSocket();
+        const server = `https://${this.address}.${configs().frp.serverAddr}`;
+        await sleep(3);
+        this.startApiCheck(server);
+        await this.listen();
+        this.startWebSocketServer();
+        return server;
+    }
+    async stopApiProxy() {
+        await this.provider.stopReverseProxyApi(this.address.toString());
+        this.stopApiCheck();
+    }
+    async startWebSocketServer() {
+        this.wss = new WebSocket.Server({ noServer: true });
+        this.server?.on('upgrade', (request, socket, head) => {
+            this.wss?.handleUpgrade(request, socket, head, (ws) => {
+                this.wss?.emit('connection', ws, request);
+            });
+        });
+        this.wss.on('connection', (ws) => {
+            let keepAliveInterval;
+            ws.on('message', async (message) => {
+                try {
+                    const { path, header, body } = JSON.parse(message.toString());
+                    keepAliveInterval = setInterval(() => {
+                        ws.ping();
+                    }, 30000);
+                    switch (path) {
+                        case '/log':
+                            await verifyWSJobOwnerSignatureMiddleware(ws, header, body, wssLogRoute);
+                            break;
+                        case '/flog':
+                            await verifyWSMiddleware(ws, header, body, wssTaskManagerLogRoute);
+                            break;
+                        case '/status':
+                            await verifyWSNodeOrJobOwnerSignatureMiddleware(ws, header, body, wssStatusRoute);
+                            break;
+                        default:
+                            ws.close(3003, 'Invalid Path');
+                            break;
+                    }
+                }
+                catch (err) {
+                    ws.close(1011, 'Internal Server Error');
+                }
+            });
+            ws.on('close', () => {
+                if (keepAliveInterval) {
+                    clearInterval(keepAliveInterval);
+                }
+                stateStreaming(this.address.toString()).unsubscribe(ws);
+            });
+        });
+    }
+    startApiCheck(server) {
+        if (!this.apiCheckInterval) {
+            this.apiCheckInterval = setInterval(async () => {
+                const isAlive = await this.testApiServerOnce(server);
+                if (!isAlive) {
+                    console.log('API proxy is offline, restarting..');
+                    await this.restartApiProxy();
+                }
+            }, 60000 * 5); // every 5 minutes
+        }
+    }
+    async registerRoutes() {
+        // Attach require objects to routes
+        this.api.use((req, _, next) => {
+            req.repository = this.repository;
+            req.provider = this.provider;
+            req.eventEmitter = this.eventEmitter;
+            req.address = this.address;
+            next();
+        });
+        this.api.use(express.json());
+        this.api.use('/job/:jobId/*', verifyJobOwnerSignatureMiddleware);
+        // GET Routes
+        this.api.get('/node/info', getNodeInfoRoute);
+        this.api.get('/', (_, res) => res.send(this.address));
+        this.api.get('/job/:jobId/info', getJobInfoRoute);
+        this.api.get('/job/:jobId/results', getJobResultsRoute);
+        this.api.get('/job/:jobId/job-definition', getJobDefinitionRoute);
+        this.api.get('/job/:jobId/ops', getOperationsStatusHandler);
+        this.api.get('/job/:jobId/ops/:opId', getOperationStatusHandler);
+        this.api.get('/job/:jobId/group/current', getCurrentGroupStatusHandler);
+        this.api.get('/job/:jobId/group/:group', getGroupStatusHandler);
+        this.api.get('/job/:jobId/endpoints', getServiceUrlRoute);
+        // POST Routes
+        this.api.post('/node/validate', verifyBackendSignatureMiddleware, postNodeValidation);
+        this.api.post('/job/:jobId/job-definition', postJobDefinitionRoute);
+        this.api.post('/job/:jobId/group/:group/move', moveGroupOperationHandler);
+        this.api.post('/job/:jobId/group/:group/operation/:opId/restart', restartOperationHandler);
+        this.api.post('/job/:jobId/group/:group/restart', restartGroupOperationHandler);
+        this.api.post('/job/:jobId/group/:group/operation/:opId/stop', stopOperationHandler);
+        this.api.post('/job/:jobId/group/:group/stop', stopGroupOperationHandler);
+        this.api.post('/job/:jobId/stop', postServiceStopRoute);
+        // Deprecated routes
+        this.api.get('/job-result/:jobId', getJobResultsRoute);
+        this.api.get('/service/url/:jobId', getServiceUrlRoute);
+        this.api.post('/job-definition/:jobId', postJobDefinitionRoute);
+        this.api.post('/service/stop/:jobId', postServiceStopRoute);
+    }
+    async listen() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+        return new Promise((resolve, reject) => {
+            this.server = this.api.listen(this.port, () => {
+                resolve(this.port);
+            });
+            this.server.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    stopApiCheck() {
+        if (this.apiCheckInterval) {
+            clearInterval(this.apiCheckInterval);
+            this.apiCheckInterval = null;
+        }
+    }
+    stopServerAndWebSocket() {
+        if (this.server) {
+            this.server.close();
+        }
+        if (this.wss) {
+            this.wss.close();
+        }
+    }
+    async stop() {
+        await this.stopApiProxy();
+        this.stopServerAndWebSocket();
+    }
+}

package/dist/NodeManager/node/api/eventsource/index.d.ts

@@ -0,0 +1,6 @@
+import { Request, Response } from 'express';
+export interface EventSource<T extends unknown> {
+    sendIfChanged: (data: T) => void;
+    closeEventSource: () => void;
+}
+export declare function createEventSource<T extends unknown>(req: Request, res: Response): EventSource<T>;

package/dist/NodeManager/node/api/eventsource/index.js

@@ -0,0 +1,35 @@
+export function createEventSource(req, res) {
+    let lastSendDataString = null;
+    function sendIfChanged(data) {
+        const dataString = JSON.stringify(data);
+        if (dataString !== lastSendDataString) {
+            res.write(`data: ${dataString}\n\n`);
+            lastSendDataString = dataString;
+        }
+    }
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+        'X-Accel-Buffering': 'no',
+    });
+    const keepaliveInterval = setInterval(() => {
+        res.write(': keep-alive\n\n');
+    }, 15000);
+    req.on('close', () => {
+        clearInterval(keepaliveInterval);
+        res.end();
+    });
+    req.on('error', () => {
+        clearInterval(keepaliveInterval);
+        res.end();
+    });
+    const closeEventSource = () => {
+        clearInterval(keepaliveInterval);
+        res.end();
+    };
+    return {
+        sendIfChanged,
+        closeEventSource,
+    };
+}

package/dist/NodeManager/node/api/middlewares/index.d.ts

@@ -0,0 +1,5 @@
+export * from './rest/verifyBackendSignatureMiddleware.js';
+export * from './rest/verifyJobOwnerSignatureMiddleware.js';
+export * from './ws/verifyWSJobOwnerSignatureMiddleware.js';
+export * from './ws/verifyWSNodeOrJobOwnerSignatureMiddleware.js';
+export * from './ws/verifyWSMiddleware.js';

package/dist/NodeManager/node/api/middlewares/index.js

@@ -0,0 +1,7 @@
+// REST API MIDDLEWARE
+export * from './rest/verifyBackendSignatureMiddleware.js';
+export * from './rest/verifyJobOwnerSignatureMiddleware.js';
+// WEBSOCKET MIDDLEWARE
+export * from './ws/verifyWSJobOwnerSignatureMiddleware.js';
+export * from './ws/verifyWSNodeOrJobOwnerSignatureMiddleware.js';
+export * from './ws/verifyWSMiddleware.js';

package/dist/NodeManager/node/api/middlewares/rest/verifyBackendSignatureMiddleware.d.ts

@@ -0,0 +1,3 @@
+import { NextFunction, Response } from 'express';
+import { NodeAPIRequest } from '../../types/index.js';
+export declare function verifyBackendSignatureMiddleware(req: NodeAPIRequest, res: Response, next: NextFunction): Promise<Response<any, Record<string, any>> | undefined>;

package/dist/NodeManager/node/api/middlewares/rest/verifyBackendSignatureMiddleware.js

@@ -0,0 +1,20 @@
+import { PublicKey } from '@solana/web3.js';
+import { getSDK } from '../../../../sdk/index.js';
+import { configs } from '../../../../configs/configs.js';
+export async function verifyBackendSignatureMiddleware(req, res, next) {
+    const sdk = getSDK();
+    try {
+        if (!sdk.authorization.validateHeader(req.headers, {
+            expiry: 300,
+            key: 'x-session-id',
+            publicKey: new PublicKey(configs().backendAuthorizationAddress),
+        })) {
+            return res.status(401).send('Unauthorized Request');
+        }
+        res.locals['session_id'] = req.headers['x-session-id'].split(':')[0];
+        next();
+    }
+    catch (error) {
+        res.status(401).send(`Unauthorized Request: ${error.message}`);
+    }
+}

package/dist/NodeManager/node/api/middlewares/rest/verifyJobOwnerSignatureMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { NextFunction, Response } from 'express';
+import { NodeAPIRequest } from '../../types/index.js';
+export declare function verifyJobOwnerSignatureMiddleware(req: NodeAPIRequest<{
+    jobId: string;
+}>, res: Response, next: NextFunction): Promise<Response<any, Record<string, any>> | undefined>;

package/dist/NodeManager/node/api/middlewares/rest/verifyJobOwnerSignatureMiddleware.js

@@ -0,0 +1,28 @@
+import { PublicKey } from '@solana/web3.js';
+import { getSDK } from '../../../../sdk/index.js';
+export async function verifyJobOwnerSignatureMiddleware(req, res, next) {
+    const sdk = getSDK();
+    const jobId = req.params.jobId;
+    if (!jobId) {
+        res.status(400).send('Expected jobId parameter.');
+        return;
+    }
+    try {
+        const job = await sdk.jobs.get(jobId);
+        if (!job) {
+            res.status(400).send(`Could not find job with id ${jobId}`);
+            return;
+        }
+        if (!sdk.authorization.validateHeader(req.headers, {
+            key: 'authorization',
+            expiry: job.timeout,
+            publicKey: new PublicKey(job.project),
+        })) {
+            return res.status(401).send('Unauthorized Request');
+        }
+        next();
+    }
+    catch (error) {
+        res.status(401).send(`Unauthorized Request: ${error.message}`);
+    }
+}

package/dist/NodeManager/node/api/middlewares/ws/verifyWSJobOwnerSignatureMiddleware.d.ts

@@ -0,0 +1,6 @@
+import WebSocket from 'ws';
+export declare function verifyWSJobOwnerSignatureMiddleware(ws: WebSocket, headers: string, body: {
+    jobAddress: string;
+}, nextFunction: (ws: WebSocket, headers: string, body: {
+    jobAddress: string;
+}) => void): Promise<void>;

package/dist/NodeManager/node/api/middlewares/ws/verifyWSJobOwnerSignatureMiddleware.js

@@ -0,0 +1,30 @@
+import { PublicKey } from '@solana/web3.js';
+import { getSDK } from '../../../../sdk/index.js';
+export async function verifyWSJobOwnerSignatureMiddleware(ws, headers, body, nextFunction) {
+    const sdk = getSDK();
+    const jobId = body.jobAddress;
+    if (!jobId) {
+        ws.close(1007, 'Expected body to contain jobAddress.');
+        return;
+    }
+    try {
+        const job = await sdk.jobs.get(jobId);
+        if (!job) {
+            ws.close(1007, `Could not find job with id ${jobId}`);
+            return;
+        }
+        try {
+            if (sdk.authorization.validate(headers, {
+                publicKey: new PublicKey(job.project),
+            })) {
+                await nextFunction(ws, headers, body);
+            }
+        }
+        catch (_) {
+            ws.close(3000, 'Unauthorized Request');
+        }
+    }
+    catch (error) {
+        ws.close(3000, `Unauthorized Request: ${error.message}`);
+    }
+}

package/dist/NodeManager/node/api/middlewares/ws/verifyWSMiddleware.d.ts

@@ -0,0 +1,6 @@
+import WebSocket from 'ws';
+export declare function verifyWSMiddleware(ws: WebSocket, headers: string, body: {
+    jobAddress: string;
+}, nextFunction: (ws: WebSocket, headers: string, body: {
+    jobAddress: string;
+}) => void): Promise<void>;

package/dist/NodeManager/node/api/middlewares/ws/verifyWSMiddleware.js

@@ -0,0 +1,20 @@
+import { getSDK } from '../../../../sdk/index.js';
+export async function verifyWSMiddleware(ws, headers, body, nextFunction) {
+    const sdk = getSDK();
+    const jobId = body.jobAddress;
+    if (!jobId) {
+        ws.close(1007, 'Expected body to contain jobAddress.');
+        return;
+    }
+    try {
+        const job = await sdk.jobs.get(jobId);
+        if (!job) {
+            ws.close(1007, `Could not find job with id ${jobId}`);
+            return;
+        }
+        nextFunction(ws, headers, body);
+    }
+    catch (error) {
+        ws.close(3000, `Unauthorized Request: ${error.message}`);
+    }
+}

package/dist/NodeManager/node/api/middlewares/ws/verifyWSNodeOrJobOwnerSignatureMiddleware.d.ts

@@ -0,0 +1,6 @@
+import WebSocket from 'ws';
+export declare function verifyWSNodeOrJobOwnerSignatureMiddleware(ws: WebSocket, headers: string, body: {
+    jobAddress: string;
+}, nextFunction: (ws: WebSocket, headers: string, body: {
+    jobAddress: string;
+}) => void): Promise<void>;

package/dist/NodeManager/node/api/middlewares/ws/verifyWSNodeOrJobOwnerSignatureMiddleware.js

@@ -0,0 +1,33 @@
+import { PublicKey } from '@solana/web3.js';
+import { getSDK } from '../../../../sdk/index.js';
+export async function verifyWSNodeOrJobOwnerSignatureMiddleware(ws, headers, body, nextFunction) {
+    const sdk = getSDK();
+    const jobId = body.jobAddress;
+    if (!jobId) {
+        ws.close(1007, 'Expected body to contain jobAddress.');
+        return;
+    }
+    try {
+        const job = await sdk.jobs.get(jobId);
+        if (!job) {
+            ws.close(1007, `Could not find job with id ${jobId}`);
+            return;
+        }
+        try {
+            if (sdk.authorization.validate(headers, {
+                publicKey: new PublicKey(job.project),
+            }) ||
+                sdk.authorization.validate(headers, {
+                    publicKey: sdk.solana.wallet.publicKey,
+                })) {
+                await nextFunction(ws, headers, body);
+            }
+        }
+        catch (_) {
+            ws.close(3000, 'Unauthorized Request');
+        }
+    }
+    catch (error) {
+        ws.close(3000, `Unauthorized Request: ${error.message}`);
+    }
+}

package/dist/NodeManager/node/api/routes/get/index.d.ts

@@ -0,0 +1,6 @@
+export * from './job-results.js';
+export * from './node-info.js';
+export * from './service-url.js';
+export * from './job-definition.js';
+export * from './job-operation-info.js';
+export * from './job-info/job-info.js';

package/dist/NodeManager/node/api/routes/get/index.js

@@ -0,0 +1,6 @@
+export * from './job-results.js';
+export * from './node-info.js';
+export * from './service-url.js';
+export * from './job-definition.js';
+export * from './job-operation-info.js';
+export * from './job-info/job-info.js';

package/dist/NodeManager/node/api/routes/get/job-definition.d.ts

@@ -0,0 +1,5 @@
+import { Response } from 'express';
+import { NodeAPIRequest } from '../../types/index.js';
+export declare function getJobDefinitionRoute(req: NodeAPIRequest<{
+    jobId: string;
+}>, res: Response): Response<any, Record<string, any>> | undefined;

package/dist/NodeManager/node/api/routes/get/job-definition.js

@@ -0,0 +1,16 @@
+export function getJobDefinitionRoute(req, res) {
+    const id = req.params.jobId;
+    if (!id) {
+        return res.status(400).send('job id parameter not provided');
+    }
+    const flowState = req.repository.getFlow(id);
+    if (!flowState) {
+        return res.status(400).send('invalid job id');
+    }
+    if (flowState.state.status === 'waiting-for-job-definition') {
+        return res
+            .status(400)
+            .send('The job definition has not yet been set. Please set the job definition and try again.');
+    }
+    res.status(200).send(JSON.stringify(flowState.jobDefinition));
+}

package/dist/NodeManager/node/api/routes/get/job-info/buildInfoObject.d.ts

@@ -0,0 +1,17 @@
+import { FlowState, OpState } from '@nosana/sdk';
+import TaskManager from '../../../../task/TaskManager.js';
+type TaskStatus = Record<string, string | null>;
+type RedactedFlowState = Omit<OpState, 'logs' | 'providerId'>;
+type RedactedFlowStateWithOpStates = Omit<FlowState, 'opStates'> & {
+    opStates: RedactedFlowState[];
+};
+type TaskResponse = {
+    all: TaskStatus | null;
+    currentGroup: string | undefined;
+    currentGroupStatus: TaskStatus | null;
+};
+export type JobInfoResponse = RedactedFlowStateWithOpStates & {
+    operations: TaskResponse | null;
+};
+export declare function buildInfoObject(flowState: FlowState, task: TaskManager | undefined): JobInfoResponse;
+export {};

package/dist/NodeManager/node/api/routes/get/job-info/buildInfoObject.js

@@ -0,0 +1,15 @@
+export function buildInfoObject(flowState, task) {
+    const { opStates, ...flowStateWithoutOpStates } = flowState;
+    return {
+        ...flowStateWithoutOpStates,
+        errors: flowState.errors ?? [],
+        opStates: opStates.map(({ logs, providerId, ...opState }) => opState),
+        operations: task
+            ? {
+                all: task.getOperationsStatus(),
+                currentGroup: task.getCurrentGroup(),
+                currentGroupStatus: task.getCurrentGroupStatus(),
+            }
+            : null,
+    };
+}

package/dist/NodeManager/node/api/routes/get/job-info/job-info.d.ts

@@ -0,0 +1,5 @@
+import { Response } from 'express';
+import { NodeAPIRequest } from '../../../types/index.js';
+export declare function getJobInfoRoute(req: NodeAPIRequest<{
+    jobId: string;
+}>, res: Response): Response<any, Record<string, any>> | undefined;

package/dist/NodeManager/node/api/routes/get/job-info/job-info.js

@@ -0,0 +1,18 @@
+import { pollActiveJob } from './pollActiveJob.js';
+import { createEventSource } from '../../../eventsource/index.js';
+export function getJobInfoRoute(req, res) {
+    const jobId = req.params.jobId;
+    if (!jobId) {
+        return res.status(400).send('Job id parameter not provided.');
+    }
+    const flowState = req.repository.getFlowState(jobId);
+    if (!flowState) {
+        return res.status(404).send('Failed to find job for provided job id.');
+    }
+    const { sendIfChanged, closeEventSource } = createEventSource(req, res);
+    const { stopPolling } = pollActiveJob(req.repository, jobId, sendIfChanged, closeEventSource);
+    req.on('close', stopPolling);
+    req.on('error', stopPolling);
+    res.on('error', stopPolling);
+    res.on('finish', stopPolling);
+}

package/dist/NodeManager/node/api/routes/get/job-info/pollActiveJob.d.ts

@@ -0,0 +1,6 @@
+import { EventSource } from '../../../eventsource/index.js';
+import { JobInfoResponse } from './buildInfoObject.js';
+import { NodeRepository } from '../../../../../repository/NodeRepository.js';
+export declare function pollActiveJob(repository: NodeRepository, jobId: string, sendIfChanged: EventSource<JobInfoResponse>['sendIfChanged'], closeEventSource: EventSource<JobInfoResponse>['closeEventSource']): {
+    stopPolling: () => void;
+};

package/dist/NodeManager/node/api/routes/get/job-info/pollActiveJob.js

@@ -0,0 +1,42 @@
+import { buildInfoObject } from './buildInfoObject.js';
+import { TaskManagerRegistry } from '../../../../task/TaskManagerRegistry.js';
+const INTERVAL_MS = 1000;
+export function pollActiveJob(repository, jobId, sendIfChanged, closeEventSource) {
+    let debounceTimer = null;
+    const stopPolling = () => {
+        if (debounceTimer)
+            clearInterval(debounceTimer);
+        closeEventSource();
+    };
+    const initialFlowState = repository.getFlowState(jobId);
+    const initialTask = TaskManagerRegistry.getInstance().get(jobId);
+    if (!initialFlowState) {
+        stopPolling();
+        return {
+            stopPolling,
+        };
+    }
+    sendIfChanged(buildInfoObject(initialFlowState, initialTask));
+    if (initialFlowState.endTime) {
+        stopPolling();
+        return {
+            stopPolling,
+        };
+    }
+    debounceTimer = setInterval(() => {
+        const flowState = repository.getFlowState(jobId);
+        const task = TaskManagerRegistry.getInstance().get(jobId);
+        if (!flowState) {
+            stopPolling();
+            return;
+        }
+        sendIfChanged(buildInfoObject(flowState, task));
+        if (flowState.endTime) {
+            stopPolling();
+            return;
+        }
+    }, INTERVAL_MS);
+    return {
+        stopPolling,
+    };
+}

package/dist/NodeManager/node/api/routes/get/job-operation-info.d.ts

@@ -0,0 +1,28 @@
+import { Response } from 'express';
+import { NodeAPIRequest } from '../../types/index.js';
+/**
+ * Returns all operation statuses for the job.
+ */
+export declare function getOperationsStatusHandler(req: NodeAPIRequest<{
+    jobId: string;
+}>, res: Response): Response<any, Record<string, any>>;
+/**
+ * Returns the status of a specific operation.
+ */
+export declare function getOperationStatusHandler(req: NodeAPIRequest<{
+    jobId: string;
+    opId: string;
+}>, res: Response): Response<any, Record<string, any>>;
+/**
+ * Returns the status of all operations in the current group.
+ */
+export declare function getCurrentGroupStatusHandler(req: NodeAPIRequest<{
+    jobId: string;
+}>, res: Response): Response<any, Record<string, any>>;
+/**
+ * Returns the status of all operations in a specified group.
+ */
+export declare function getGroupStatusHandler(req: NodeAPIRequest<{
+    jobId: string;
+    group: string;
+}>, res: Response): Response<any, Record<string, any>>;

package/dist/NodeManager/node/api/routes/get/job-operation-info.js

@@ -0,0 +1,53 @@
+import { TaskManagerRegistry } from '../../../task/TaskManagerRegistry.js';
+/**
+ * Returns all operation statuses for the job.
+ */
+export function getOperationsStatusHandler(req, res) {
+    const { jobId } = req.params;
+    const task = TaskManagerRegistry.getInstance().get(jobId);
+    if (!task) {
+        return res.status(400).send('invalid job id');
+    }
+    return res.status(200).json(task.getOperationsStatus());
+}
+/**
+ * Returns the status of a specific operation.
+ */
+export function getOperationStatusHandler(req, res) {
+    const { jobId, opId } = req.params;
+    const task = TaskManagerRegistry.getInstance().get(jobId);
+    if (!task) {
+        return res.status(400).send('invalid job id');
+    }
+    const operation = task.getOperationStatus(opId);
+    if (!operation) {
+        return res.status(404).send('operation not found');
+    }
+    return res.status(200).json(operation);
+}
+/**
+ * Returns the status of all operations in the current group.
+ */
+export function getCurrentGroupStatusHandler(req, res) {
+    const { jobId } = req.params;
+    const task = TaskManagerRegistry.getInstance().get(jobId);
+    if (!task) {
+        return res.status(400).send('invalid job id');
+    }
+    return res.status(200).json(task.getCurrentGroupStatus());
+}
+/**
+ * Returns the status of all operations in a specified group.
+ */
+export function getGroupStatusHandler(req, res) {
+    const { jobId, group } = req.params;
+    const task = TaskManagerRegistry.getInstance().get(jobId);
+    if (!task) {
+        return res.status(400).send('invalid job id');
+    }
+    const groupStatus = task.getGroupStatus(group);
+    if (!groupStatus) {
+        return res.status(404).send('group not found');
+    }
+    return res.status(200).json(groupStatus);
+}