@nosana/node 1.0.0-rc

package/dist/NodeManager/node/market/marketHandler.d.ts

@@ -0,0 +1,30 @@
+import { Client as SDK, Market } from '@nosana/sdk';
+import { PublicKey } from '@solana/web3.js';
+export declare class MarketHandler {
+    private sdk;
+    private market;
+    private address;
+    private checkQueuedInterval?;
+    private inMarket;
+    constructor(sdk: SDK);
+    clear(): void;
+    isInMarket(): boolean;
+    setInMarket(): void;
+    check(market: string): Promise<Market>;
+    stopMarket(): Promise<boolean>;
+    getJobMarket(market: string): Promise<Market>;
+    getMarket(): Market | undefined;
+    setMarket(market: string): Promise<Market>;
+    checkQueuedInMarket(): Promise<Market | undefined>;
+    join(accessKey?: PublicKey): Promise<Market>;
+    refresh(): Promise<Market>;
+    leave(): Promise<void>;
+    processMarketQueuePosition(market: Market, isFirst: boolean): {
+        position: number;
+        count: number;
+    };
+    startMarketQueueMonitoring(updateCallback: (market: Market | undefined) => void): Promise<void>;
+    stopMarketQueueMonitoring(): void;
+    stop(): Promise<void>;
+    clean(): Promise<void>;
+}

package/dist/NodeManager/node/market/marketHandler.js

@@ -0,0 +1,137 @@
+export class MarketHandler {
+    constructor(sdk) {
+        this.sdk = sdk;
+        this.inMarket = false;
+        this.address = this.sdk.solana.provider.wallet.publicKey;
+    }
+    clear() {
+        this.market = undefined;
+    }
+    isInMarket() {
+        return this.inMarket;
+    }
+    setInMarket() {
+        this.inMarket = true;
+    }
+    async check(market) {
+        try {
+            return await this.sdk.jobs.getMarket(market);
+        }
+        catch (error) {
+            throw new Error(`Error resolving Market: ${error}`);
+        }
+    }
+    async stopMarket() {
+        if (this.market) {
+            try {
+                await this.sdk.jobs.stop(this.market.address);
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async getJobMarket(market) {
+        try {
+            this.market = await this.sdk.jobs.getMarket(market);
+            return this.market;
+        }
+        catch (error) {
+            throw new Error('market does not exists');
+        }
+    }
+    getMarket() {
+        return this.market;
+    }
+    async setMarket(market) {
+        try {
+            this.market = await this.sdk.jobs.getMarket(market);
+            return this.market;
+        }
+        catch (error) {
+            throw new Error('market does not exists');
+        }
+    }
+    async checkQueuedInMarket() {
+        let markets = [];
+        markets = await this.sdk.jobs.allMarkets();
+        for (const market of markets) {
+            if (market?.queue?.some((e) => e.toString() === this.address.toString())) {
+                this.market = market;
+                return this.getMarket();
+            }
+        }
+        return undefined;
+    }
+    async join(accessKey) {
+        if (!this.market) {
+            throw new Error('market not defined');
+        }
+        try {
+            await this.sdk.jobs.work(this.market.address, accessKey);
+            this.inMarket = true;
+        }
+        catch (e) {
+            throw new Error(`could not join queue: ${e}`);
+        }
+        return this.market;
+    }
+    async refresh() {
+        return this.setMarket(this.market?.address.toString());
+    }
+    async leave() {
+        if (this.market) {
+            try {
+                await this.sdk.jobs.stop(this.market.address);
+            }
+            catch (error) { }
+            this.inMarket = false;
+        }
+    }
+    processMarketQueuePosition(market, isFirst) {
+        const position = market.queue.findIndex((e) => e.toString() === this.address.toString()) + 1;
+        return {
+            position,
+            count: market.queue.length,
+        };
+    }
+    async startMarketQueueMonitoring(updateCallback) {
+        // Ensure no multiple intervals
+        this.stopMarketQueueMonitoring();
+        try {
+            // Perform an immediate check
+            const queuedMarketInfo = await this.checkQueuedInMarket();
+            updateCallback(queuedMarketInfo);
+        }
+        catch (error) {
+            console.warn('\nCould not update queue status', error);
+        }
+        // Check market queue status every minute
+        this.checkQueuedInterval = setInterval(async () => {
+            try {
+                const queuedMarketInfo = await this.checkQueuedInMarket();
+                updateCallback(queuedMarketInfo);
+            }
+            catch (error) {
+                console.warn('\nCould not update queue status', error);
+            }
+        }, 60000);
+    }
+    // Stop monitoring market queue status
+    stopMarketQueueMonitoring() {
+        if (this.checkQueuedInterval) {
+            clearInterval(this.checkQueuedInterval);
+            this.checkQueuedInterval = undefined; // Clean up reference
+        }
+    }
+    async stop() {
+        this.stopMarketQueueMonitoring();
+        await this.leave();
+        this.clear();
+    }
+    async clean() {
+        this.stopMarketQueueMonitoring();
+        this.clear();
+    }
+}

package/dist/NodeManager/node/register/index.d.ts

@@ -0,0 +1,16 @@
+import { Client } from '@nosana/sdk';
+import { Provider } from '../../provider/Provider.js';
+import { NodeRepository } from '../../repository/NodeRepository.js';
+export declare class RegisterHandler {
+    private sdk;
+    private provider;
+    private repository;
+    private nodeId;
+    private answers;
+    constructor(sdk: Client, provider: Provider, repository: NodeRepository);
+    private gainConstent;
+    private generateHeaders;
+    private runSpecs;
+    private submitOnboarding;
+    register(): Promise<void>;
+}

package/dist/NodeManager/node/register/index.js

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import { confirm, input } from '@inquirer/prompts';
+import { configs } from '../../configs/configs.js';
+import { specsAndNetworkJob } from '../../../static/index.js';
+import { applyLoggingProxyToClass } from '../../monitoring/proxy/loggingProxy.js';
+import { generateRandomId } from '../utils/generateRandomId.js';
+import TaskManager from '../task/TaskManager.js';
+export class RegisterHandler {
+    constructor(sdk, provider, repository) {
+        this.sdk = sdk;
+        this.provider = provider;
+        this.repository = repository;
+        this.nodeId = this.sdk.solana.provider.wallet.publicKey.toString();
+        applyLoggingProxyToClass(this);
+    }
+    async gainConstent() {
+        this.answers = {
+            email: await input({
+                message: 'Your Email Address',
+                validate: (value) => /\S+@\S+\.\S+/.test(value),
+            }),
+            discord: await input({
+                message: 'Join our Discord server for direct support from the team and community: https://nosana.com/discord. \nDiscord username:',
+            }),
+            twitter: await input({
+                message: "What is your Twitter username? (If you don't use Twitter, leave blank)",
+            }),
+        };
+        if (!this.answers.email) {
+            console.log(chalk.red('Email address is required'));
+            process.exit();
+        }
+        const accept = await confirm({
+            message: `Have you read the Participation Agreement and agree to the terms and conditions contained within?\nParticipation agreement: ${chalk.blue('https://drive.google.com/file/d/1dFWCT5Zon08pCPrftdxB9ByvbuDafTwy/view')}`,
+        });
+        if (!accept) {
+            console.log(chalk.red('To continue you must agree to the terms and conditions'));
+            process.exit();
+        }
+    }
+    // TODO: convert backend to support sdk.authorization.generate()
+    async generateHeaders() {
+        const conf = configs();
+        const signature = (await this.sdk.solana.signMessage(conf.signMessage));
+        const base64Signature = Buffer.from(signature).toString('base64');
+        return `${this.nodeId}:${base64Signature}`;
+    }
+    async runSpecs() {
+        const flowId = generateRandomId(32);
+        const task = new TaskManager(this.provider, this.repository, flowId, this.sdk.solana.wallet.publicKey.toString(), specsAndNetworkJob);
+        task.bootstrap();
+        await task.start();
+        const result = this.repository.getFlow(flowId);
+        if (!result || result.state.status !== 'success') {
+            throw new Error('Registration Benchmark Failed');
+        }
+        return result;
+    }
+    async submitOnboarding(results) {
+        try {
+            const headers = new Headers();
+            headers.append('Authorization', await this.generateHeaders());
+            headers.append('Content-Type', 'application/json');
+            const joinTestGridResult = await fetch(`${configs().backendUrl}/nodes/join-test-grid`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    ...this.answers,
+                    nodeAddress: this.nodeId,
+                    results,
+                }),
+            });
+            if (!joinTestGridResult.ok) {
+                console.error('Error whilst submiting onboarding request.');
+                process.exit();
+            }
+        }
+        catch (error) {
+            console.error('Error whilst submiting onboarding request.', error);
+            process.exit();
+        }
+    }
+    async register() {
+        await this.gainConstent();
+        const results = await this.runSpecs();
+        await this.submitOnboarding(results.state.opStates);
+    }
+}

package/dist/NodeManager/node/resource/definition/index.d.ts

@@ -0,0 +1,2 @@
+export declare const s3HelperImage = "registry.hub.docker.com/nosana/resource-manager:1.1.8";
+export declare const nosanaBucket = "https://models.nosana.io";

package/dist/NodeManager/node/resource/definition/index.js

@@ -0,0 +1,2 @@
+export const s3HelperImage = 'registry.hub.docker.com/nosana/resource-manager:1.1.8';
+export const nosanaBucket = 'https://models.nosana.io';

package/dist/NodeManager/node/resource/helpers/createHFArgs.d.ts

@@ -0,0 +1,6 @@
+import { ContainerCreateOptions } from 'dockerode';
+export declare const createHFArgs: (volumeName: string, hf: {
+    repo: string;
+    revision?: string;
+    files?: string[];
+}, accessToken?: string | undefined) => ContainerCreateOptions;

package/dist/NodeManager/node/resource/helpers/createHFArgs.js

@@ -0,0 +1,26 @@
+import { s3HelperImage } from '../definition/index.js';
+export const createHFArgs = (volumeName, hf, accessToken) => ({
+    AttachStdin: false,
+    AttachStdout: true,
+    AttachStderr: true,
+    Tty: false,
+    OpenStdin: false,
+    StdinOnce: false,
+    Cmd: [
+        'HF',
+        hf.repo,
+        hf.revision ?? (hf.files ? 'main' : ''),
+        hf.files ? hf.files.join(',') : '',
+    ],
+    Image: s3HelperImage,
+    Env: accessToken ? [`HUGGING_FACE_TOKEN=${accessToken}`] : undefined,
+    HostConfig: {
+        Mounts: [
+            {
+                Target: '/s3/temp',
+                Source: volumeName,
+                Type: 'volume',
+            },
+        ],
+    },
+});

package/dist/NodeManager/node/resource/helpers/createOllamaArgs.d.ts

@@ -0,0 +1,2 @@
+import { ContainerCreateOptions } from 'dockerode';
+export declare const createOllamaArgs: (volumeName: string, model: string) => ContainerCreateOptions;

package/dist/NodeManager/node/resource/helpers/createOllamaArgs.js

@@ -0,0 +1,20 @@
+import { s3HelperImage } from '../definition/index.js';
+export const createOllamaArgs = (volumeName, model) => ({
+    AttachStdin: false,
+    AttachStdout: true,
+    AttachStderr: true,
+    Tty: false,
+    OpenStdin: false,
+    StdinOnce: false,
+    Cmd: ['Ollama', model],
+    Image: s3HelperImage,
+    HostConfig: {
+        Mounts: [
+            {
+                Target: '/s3/temp',
+                Source: volumeName,
+                Type: 'volume',
+            },
+        ],
+    },
+});

package/dist/NodeManager/node/resource/helpers/createResourceName.d.ts

@@ -0,0 +1,2 @@
+import { RequiredResource } from '@nosana/sdk';
+export declare function createResourceName(resource: RequiredResource): string;

package/dist/NodeManager/node/resource/helpers/createResourceName.js

@@ -0,0 +1,18 @@
+import { nosanaBucket } from '../definition/index.js';
+export function createResourceName(resource) {
+    switch (resource.type) {
+        case 'S3':
+            const s3Resource = resource;
+            if (s3Resource.url) {
+                return s3Resource.url.replace('s3://nos-ai-models-qllsn32u', nosanaBucket);
+            }
+            return s3Resource
+                .buckets.map((bucket) => bucket.url)
+                .join('-');
+        case 'HF':
+            const hfResource = resource;
+            return `${hfResource.repo}${hfResource.revision ? '-' + hfResource.revision : ''}${hfResource.files ? '-' + hfResource.files.join('-') : ''}`;
+        case 'Ollama':
+            return resource.model;
+    }
+}

package/dist/NodeManager/node/resource/helpers/createS3Args.d.ts

@@ -0,0 +1,7 @@
+import { ContainerCreateOptions } from 'dockerode';
+import { S3Auth } from '@nosana/sdk/dist/types/resources';
+export declare const createS3Args: (volumeName: string, s3: {
+    url: string;
+    files?: string[];
+    bucket?: string;
+}, s3Auth: S3Auth | undefined) => ContainerCreateOptions;

package/dist/NodeManager/node/resource/helpers/createS3Args.js

@@ -0,0 +1,32 @@
+import { nosanaBucket, s3HelperImage } from '../definition/index.js';
+export const createS3Args = (volumeName, s3, s3Auth) => ({
+    AttachStdin: false,
+    AttachStdout: true,
+    AttachStderr: true,
+    Tty: false,
+    OpenStdin: false,
+    StdinOnce: false,
+    Cmd: [
+        'S3',
+        s3.url.replace('s3://nos-ai-models-qllsn32u', nosanaBucket),
+        s3.files ? s3.files.join(',') : '',
+    ],
+    Image: s3HelperImage,
+    Env: s3Auth
+        ? [
+            s3.bucket ? `BUCKET=${s3.bucket}` : '',
+            `REGION=${s3Auth.REGION}`,
+            `ACCESS_KEY_ID=${s3Auth.ACCESS_KEY_ID}`,
+            `SECRET_ACCESS_KEY=${s3Auth.SECRET_ACCESS_KEY}`,
+        ]
+        : undefined,
+    HostConfig: {
+        Mounts: [
+            {
+                Target: '/s3/temp',
+                Source: volumeName,
+                Type: 'volume',
+            },
+        ],
+    },
+});

package/dist/NodeManager/node/resource/helpers/hasDockerVolume.d.ts

@@ -0,0 +1,2 @@
+import { VolumeInspectInfo } from 'dockerode';
+export declare function hasDockerVolume(volume: string, volumes: VolumeInspectInfo[]): boolean;

package/dist/NodeManager/node/resource/helpers/hasDockerVolume.js

@@ -0,0 +1,3 @@
+export function hasDockerVolume(volume, volumes) {
+    return volumes.findIndex((vol) => vol.Name === volume) !== -1;
+}

package/dist/NodeManager/node/resource/helpers/hoursSunceDate.d.ts

@@ -0,0 +1 @@
+export declare function hoursSinceDate(date: Date): number;

package/dist/NodeManager/node/resource/helpers/hoursSunceDate.js

@@ -0,0 +1,3 @@
+export function hoursSinceDate(date) {
+    return Math.abs(date.getTime() - new Date().getTime()) / 36e5;
+}

package/dist/NodeManager/node/resource/helpers/repoTagsContainsImage.d.ts

@@ -0,0 +1 @@
+export declare function repoTagsContainsImage(image: string, repoTags: string[] | undefined): boolean;

package/dist/NodeManager/node/resource/helpers/repoTagsContainsImage.js

@@ -0,0 +1,13 @@
+export function repoTagsContainsImage(image, repoTags) {
+    if (!repoTags)
+        return false;
+    const imageWithTag = `${image}${!image.includes(':') ? ':latest' : ''}`;
+    const possible_options = [
+        imageWithTag,
+        `docker.io/${imageWithTag}`,
+        `docker.io/library/${imageWithTag}`,
+        `registry.hub.docker.com//${imageWithTag}`,
+        `registry.hub.docker.com/library/${imageWithTag}`,
+    ];
+    return repoTags.some((tag) => possible_options.includes(tag));
+}

package/dist/NodeManager/node/resource/image/imageManager.d.ts

@@ -0,0 +1,13 @@
+import { ContainerOrchestrationInterface } from '../../../provider/containerOrchestration/interface.js';
+import { NodeRepository } from '../../../repository/NodeRepository.js';
+export declare class ImageManager {
+    private containerOrchestration;
+    private repository;
+    private fetched;
+    private market_required_images;
+    constructor(containerOrchestration: ContainerOrchestrationInterface, repository: NodeRepository);
+    pullMarketRequiredImages(required_images: string[]): Promise<void>;
+    pruneImages(): Promise<void>;
+    resyncImagesDB(): Promise<void>;
+    setImage(image: string, isPrivate?: boolean): Promise<void>;
+}

package/dist/NodeManager/node/resource/image/imageManager.js

@@ -0,0 +1,66 @@
+import { applyLoggingProxyToClass } from '../../../monitoring/proxy/loggingProxy.js';
+import { hoursSinceDate } from '../helpers/hoursSunceDate.js';
+import { repoTagsContainsImage } from '../helpers/repoTagsContainsImage.js';
+export class ImageManager {
+    constructor(containerOrchestration, repository) {
+        this.containerOrchestration = containerOrchestration;
+        this.repository = repository;
+        this.fetched = false;
+        this.market_required_images = [];
+        applyLoggingProxyToClass(this);
+    }
+    async pullMarketRequiredImages(required_images) {
+        this.fetched = true;
+        this.market_required_images = required_images;
+        for (const image of required_images) {
+            if (!(await this.containerOrchestration.hasImage(image))) {
+                await this.containerOrchestration.pullImage(image);
+            }
+            if (!this.repository.getImageResource(image)) {
+                this.repository.updateImageResource(image, {
+                    required: true,
+                    lastUsed: new Date(),
+                    usage: 1,
+                });
+            }
+        }
+    }
+    async pruneImages() {
+        const cachedImages = await this.containerOrchestration.listImages();
+        for (const { Id, RepoTags } of cachedImages) {
+            const dbEntry = Object.entries(this.repository.getImagesResources()).find((img) => (repoTagsContainsImage(img[0], RepoTags) ? img : undefined));
+            if (dbEntry && dbEntry[1].required) {
+                continue;
+            }
+            await this.containerOrchestration.deleteImage(Id);
+            if (dbEntry) {
+                this.repository.deleteImageResource(dbEntry[0]);
+            }
+        }
+    }
+    async resyncImagesDB() {
+        for (const [image, { lastUsed, required, isPrivate }] of Object.entries(this.repository.getImagesResources())) {
+            if (!(await this.containerOrchestration.hasImage(image))) {
+                this.repository.deleteImageResource(image);
+                continue;
+            }
+            if ((!this.fetched && required) ||
+                this.market_required_images.includes(image)) {
+                continue;
+            }
+            const hoursSinceLastUsed = hoursSinceDate(new Date(lastUsed));
+            if (hoursSinceLastUsed > 24 || isPrivate) {
+                await this.containerOrchestration.deleteImage(image);
+                this.repository.deleteImageResource(image);
+            }
+        }
+    }
+    async setImage(image, isPrivate = false) {
+        const imageObj = this.repository.getImageResource(image);
+        this.repository.updateImageResource(image, {
+            lastUsed: new Date(),
+            usage: imageObj?.usage + 1 || 1,
+            isPrivate,
+        });
+    }
+}

package/dist/NodeManager/node/resource/resourceManager.d.ts

@@ -0,0 +1,21 @@
+import { Resource } from '@nosana/sdk/dist/types/resources.js';
+import { ContainerOrchestrationInterface } from '../../provider/containerOrchestration/interface.js';
+import { NodeRepository } from '../../repository/NodeRepository.js';
+import { ImageManager } from './image/imageManager.js';
+import { VolumeManager } from './volume/volumeManager.js';
+export declare class ResourceManager {
+    private containerOrchestration;
+    private repository;
+    private required_market;
+    images: ImageManager;
+    volumes: VolumeManager;
+    constructor(containerOrchestration: ContainerOrchestrationInterface, repository: NodeRepository);
+    resyncResourcesDB(): Promise<void>;
+    fetchMarketRequiredResources(market: string): Promise<void>;
+    prune(): Promise<void>;
+    getResourceVolumes(resources: Resource[], controller: AbortController): Promise<{
+        dest: string;
+        name: string;
+        readonly?: boolean;
+    }[]>;
+}

package/dist/NodeManager/node/resource/resourceManager.js

@@ -0,0 +1,57 @@
+import { clientSelector } from '../../client/index.js';
+import { createResourceName } from './helpers/createResourceName.js';
+import { ImageManager } from './image/imageManager.js';
+import { VolumeManager } from './volume/volumeManager.js';
+export class ResourceManager {
+    constructor(containerOrchestration, repository) {
+        this.containerOrchestration = containerOrchestration;
+        this.repository = repository;
+        this.images = new ImageManager(containerOrchestration, repository);
+        this.volumes = new VolumeManager(containerOrchestration, repository);
+    }
+    async resyncResourcesDB() {
+        await this.images.resyncImagesDB();
+        await this.volumes.resyncResourcesDB();
+        if (this.required_market) {
+            await this.fetchMarketRequiredResources(this.required_market);
+        }
+    }
+    async fetchMarketRequiredResources(market) {
+        this.required_market = market;
+        try {
+            const { data, error } = await clientSelector().GET('/api/markets/{id}/required-resources', { params: { path: { id: market } } });
+            if (error) {
+                return;
+            }
+            await this.images.pullMarketRequiredImages(data.required_images);
+            await this.volumes.pullMarketRequiredVolumes(data.required_remote_resources);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async prune() {
+        await this.images.pruneImages();
+        await this.volumes.pruneVolumes();
+    }
+    async getResourceVolumes(resources, controller) {
+        const volumes = [];
+        for (const resource of resources) {
+            await this.volumes.createRemoteVolume(resource, controller);
+            if ((await this.volumes.hasVolume(resource)) === false) {
+                const error = new Error(`Missing required resource ${createResourceName(resource)}.`);
+                throw error;
+            }
+            volumes.push({
+                dest: resource.type === 'Ollama'
+                    ? resource.target === undefined
+                        ? '/root/.ollama/models'
+                        : resource.target
+                    : resource.target,
+                name: await this.volumes.getVolume(resource),
+                readonly: resource.type === 'S3' && resource.allowWrite ? false : true,
+            });
+        }
+        return volumes;
+    }
+}

package/dist/NodeManager/node/resource/volume/volumeManager.d.ts

@@ -0,0 +1,20 @@
+import { Resource } from '@nosana/sdk/dist/types/resources.js';
+import { RequiredResource } from '@nosana/sdk';
+import { ContainerOrchestrationInterface } from '../../../provider/containerOrchestration/interface.js';
+import { NodeRepository } from '../../../repository/NodeRepository.js';
+export declare class VolumeManager {
+    private containerOrchestration;
+    private repository;
+    private fetched;
+    private market_required_volumes;
+    private progressBarReporter;
+    constructor(containerOrchestration: ContainerOrchestrationInterface, repository: NodeRepository);
+    pullMarketRequiredVolumes(remoteResources: RequiredResource[]): Promise<void>;
+    createRemoteVolume(resource: RequiredResource, controller: AbortController): Promise<string>;
+    private runResourceManagerContainer;
+    setVolume(bucket: string, volume: string): Promise<void>;
+    hasVolume(resource: Resource): Promise<boolean>;
+    getVolume(resource: RequiredResource | Resource): Promise<string>;
+    pruneVolumes(): Promise<void>;
+    resyncResourcesDB(): Promise<void>;
+}