jitar 0.1.0

package/dist/server/JitarServer.js

@@ -0,0 +1,109 @@
+import { Server as OvernightServer } from '@overnightjs/core';
+import bodyParser from 'body-parser';
+import { Logger } from 'tslog';
+import LocalGateway from '../runtime/LocalGateway.js';
+import LocalNode from '../runtime/LocalNode.js';
+import LocalRepository from '../runtime/LocalRepository.js';
+import Proxy from '../runtime/Proxy.js';
+import RuntimeConfigurationLoader from './utils/RuntimeConfigurationLoader.js';
+import RuntimeConfigurator from './utils/RuntimeConfigurator.js';
+import ServerOptionsReader from './utils/ServerOptionsReader.js';
+import AssetsController from './controllers/AssetsController.js';
+import HealthController from './controllers/HealthController.js';
+import JitarController from './controllers/JitarController.js';
+import ModulesController from './controllers/ModulesController.js';
+import NodesController from './controllers/NodesController.js';
+import ProceduresController from './controllers/ProceduresController.js';
+import ProxyController from './controllers/ProxyController.js';
+import RPCController from './controllers/RPCController.js';
+import RuntimeDefaults from './definitions/RuntimeDefaults.js';
+import RuntimeNotAvaiable from './errors/RuntimeNotAvaiable.js';
+const STARTUP_MESSAGE = `
+       ██ ██ ████████  █████  ██████  
+       ██ ██    ██    ██   ██ ██   ██ 
+       ██ ██    ██    ███████ ██████  
+  ██   ██ ██    ██    ██   ██ ██   ██ 
+   █████  ██    ██    ██   ██ ██   ██
+  ____________________________________
+  By Masking Technology (masking.tech)
+`;
+export default class JitarServer extends OvernightServer {
+    #runtime;
+    constructor() {
+        super(false);
+        this.app.use(bodyParser.json());
+        this.app.use(bodyParser.urlencoded({ extended: true }));
+    }
+    async start() {
+        console.log(STARTUP_MESSAGE);
+        const options = await ServerOptionsReader.read();
+        const configuration = await RuntimeConfigurationLoader.load(options.config);
+        const runtime = await RuntimeConfigurator.configure(configuration);
+        const logger = this.#createLogger(options.loglevel);
+        this.#addControllers(configuration, runtime, logger);
+        const url = new URL(configuration.url ?? RuntimeDefaults.URL);
+        await this.#startServer(url.port);
+        this.#runtime = runtime;
+        logger.info(`Server started and listening at port ${url.port}`);
+    }
+    addHealthCheck(name, healthCheck) {
+        if (this.#runtime === undefined) {
+            throw new RuntimeNotAvaiable();
+        }
+        this.#runtime.addHealthCheck(name, healthCheck);
+    }
+    #createLogger(level) {
+        return new Logger({
+            displayFilePath: 'hidden',
+            minLevel: level
+        });
+    }
+    #addControllers(configuration, runtime, logger) {
+        if (configuration.standalone !== undefined && runtime instanceof Proxy) {
+            const index = configuration.standalone.index ?? RuntimeDefaults.INDEX;
+            this.#addStandAloneControllers(runtime, logger, index);
+        }
+        else if (configuration.repository !== undefined && runtime instanceof LocalRepository) {
+            const index = configuration.repository.index ?? RuntimeDefaults.INDEX;
+            this.#addRepositoryControllers(runtime, logger, index);
+        }
+        else if (configuration.gateway !== undefined && runtime instanceof LocalGateway) {
+            this.#addGatewayControllers(runtime, logger);
+        }
+        else if (configuration.node !== undefined && runtime instanceof LocalNode) {
+            this.#addNodeControllers(runtime, logger);
+        }
+        else if (configuration.proxy !== undefined && runtime instanceof Proxy) {
+            this.#addProxyControllers(runtime, logger);
+        }
+    }
+    #addStandAloneControllers(proxy, logger, index) {
+        super.addControllers(new HealthController(proxy, logger));
+        super.addControllers(new JitarController(this.app));
+        super.addControllers(new ModulesController(proxy, logger));
+        super.addControllers(new ProceduresController(proxy, logger));
+        super.addControllers(new RPCController(proxy, logger, true));
+        super.addControllers(new AssetsController(this.app, proxy, index, logger));
+    }
+    #addRepositoryControllers(repository, logger, index) {
+        super.addControllers(new JitarController(this.app));
+        super.addControllers(new ModulesController(repository, logger));
+        super.addControllers(new AssetsController(this.app, repository, index, logger));
+    }
+    #addGatewayControllers(gateway, logger) {
+        super.addControllers(new NodesController(gateway, logger));
+        super.addControllers(new ProceduresController(gateway, logger));
+        super.addControllers(new RPCController(gateway, logger, false));
+    }
+    #addNodeControllers(node, logger) {
+        super.addControllers(new HealthController(node, logger));
+        super.addControllers(new ProceduresController(node, logger));
+        super.addControllers(new RPCController(node, logger, true));
+    }
+    #addProxyControllers(proxy, logger) {
+        super.addControllers(new ProxyController(this.app, proxy, logger));
+    }
+    async #startServer(port) {
+        return new Promise(resolve => { this.app.listen(port, resolve); });
+    }
+}

package/dist/server/configuration/GatewayConfiguration.d.ts

@@ -0,0 +1,3 @@
+export default class GatewayConfiguration {
+    monitor?: number;
+}

package/dist/server/configuration/GatewayConfiguration.js

@@ -0,0 +1,18 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { IsOptional, IsNumber } from 'class-validator';
+export default class GatewayConfiguration {
+    monitor;
+}
+__decorate([
+    IsNumber(),
+    IsOptional(),
+    __metadata("design:type", Number)
+], GatewayConfiguration.prototype, "monitor", void 0);

package/dist/server/configuration/NodeConfiguration.d.ts

@@ -0,0 +1,5 @@
+export default class NodeConfiguration {
+    gateway?: string;
+    repository: string;
+    segments?: string[];
+}

package/dist/server/configuration/NodeConfiguration.js

@@ -0,0 +1,28 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { IsArray, IsUrl, IsOptional } from 'class-validator';
+export default class NodeConfiguration {
+    gateway;
+    repository = '';
+    segments;
+}
+__decorate([
+    IsUrl(),
+    IsOptional(),
+    __metadata("design:type", String)
+], NodeConfiguration.prototype, "gateway", void 0);
+__decorate([
+    IsUrl(),
+    __metadata("design:type", Object)
+], NodeConfiguration.prototype, "repository", void 0);
+__decorate([
+    IsArray(),
+    __metadata("design:type", Array)
+], NodeConfiguration.prototype, "segments", void 0);

package/dist/server/configuration/ProxyConfiguration.d.ts

@@ -0,0 +1,5 @@
+export default class ProxyConfiguration {
+    node?: string;
+    gateway?: string;
+    repository?: string;
+}

package/dist/server/configuration/ProxyConfiguration.js

@@ -0,0 +1,29 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { IsUrl, IsOptional } from 'class-validator';
+export default class ProxyConfiguration {
+    node;
+    gateway;
+    repository;
+}
+__decorate([
+    IsUrl(),
+    IsOptional(),
+    __metadata("design:type", String)
+], ProxyConfiguration.prototype, "node", void 0);
+__decorate([
+    IsUrl(),
+    IsOptional(),
+    __metadata("design:type", String)
+], ProxyConfiguration.prototype, "gateway", void 0);
+__decorate([
+    IsUrl(),
+    __metadata("design:type", String)
+], ProxyConfiguration.prototype, "repository", void 0);

package/dist/server/configuration/RepositoryConfiguration.d.ts

@@ -0,0 +1,5 @@
+export default class RepositoryConfiguration {
+    source?: string;
+    cache?: string;
+    index?: string;
+}

package/dist/server/configuration/RepositoryConfiguration.js

@@ -0,0 +1,30 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { IsOptional, IsString } from 'class-validator';
+export default class RepositoryConfiguration {
+    source;
+    cache;
+    index;
+}
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], RepositoryConfiguration.prototype, "source", void 0);
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], RepositoryConfiguration.prototype, "cache", void 0);
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], RepositoryConfiguration.prototype, "index", void 0);

package/dist/server/configuration/RuntimeConfiguration.d.ts

@@ -0,0 +1,13 @@
+import GatewayConfiguration from './GatewayConfiguration.js';
+import NodeConfiguration from './NodeConfiguration.js';
+import ProxyConfiguration from './ProxyConfiguration.js';
+import RepositoryConfiguration from './RepositoryConfiguration.js';
+import StandaloneConfiguration from './StandaloneConfiguration.js';
+export default class RuntimeConfiguration {
+    url?: string;
+    standalone?: StandaloneConfiguration;
+    repository?: RepositoryConfiguration;
+    gateway?: GatewayConfiguration;
+    node?: NodeConfiguration;
+    proxy?: ProxyConfiguration;
+}

package/dist/server/configuration/RuntimeConfiguration.js

@@ -0,0 +1,48 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { IsOptional, IsUrl } from 'class-validator';
+import GatewayConfiguration from './GatewayConfiguration.js';
+import NodeConfiguration from './NodeConfiguration.js';
+import ProxyConfiguration from './ProxyConfiguration.js';
+import RepositoryConfiguration from './RepositoryConfiguration.js';
+import StandaloneConfiguration from './StandaloneConfiguration.js';
+export default class RuntimeConfiguration {
+    url;
+    standalone;
+    repository;
+    gateway;
+    node;
+    proxy;
+}
+__decorate([
+    IsUrl(),
+    IsOptional(),
+    __metadata("design:type", String)
+], RuntimeConfiguration.prototype, "url", void 0);
+__decorate([
+    IsOptional(),
+    __metadata("design:type", StandaloneConfiguration)
+], RuntimeConfiguration.prototype, "standalone", void 0);
+__decorate([
+    IsOptional(),
+    __metadata("design:type", RepositoryConfiguration)
+], RuntimeConfiguration.prototype, "repository", void 0);
+__decorate([
+    IsOptional(),
+    __metadata("design:type", GatewayConfiguration)
+], RuntimeConfiguration.prototype, "gateway", void 0);
+__decorate([
+    IsOptional(),
+    __metadata("design:type", NodeConfiguration)
+], RuntimeConfiguration.prototype, "node", void 0);
+__decorate([
+    IsOptional(),
+    __metadata("design:type", ProxyConfiguration)
+], RuntimeConfiguration.prototype, "proxy", void 0);

package/dist/server/configuration/ServerOptions.d.ts

@@ -0,0 +1,4 @@
+export default class ServerOptions {
+    loglevel: string;
+    config: string;
+}

package/dist/server/configuration/ServerOptions.js

@@ -0,0 +1,25 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Contains, IsOptional, IsString } from 'class-validator';
+export default class ServerOptions {
+    loglevel = 'info';
+    config = 'config.json';
+}
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", Object)
+], ServerOptions.prototype, "loglevel", void 0);
+__decorate([
+    IsString(),
+    Contains('.json'),
+    IsOptional(),
+    __metadata("design:type", Object)
+], ServerOptions.prototype, "config", void 0);

package/dist/server/configuration/StandaloneConfiguration.d.ts

@@ -0,0 +1,6 @@
+export default class StandaloneConfiguration {
+    source?: string;
+    cache?: string;
+    index?: string;
+    segments?: string[];
+}

package/dist/server/configuration/StandaloneConfiguration.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { IsArray, IsOptional, IsString } from 'class-validator';
+export default class StandaloneConfiguration {
+    source;
+    cache;
+    index;
+    segments;
+}
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], StandaloneConfiguration.prototype, "source", void 0);
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], StandaloneConfiguration.prototype, "cache", void 0);
+__decorate([
+    IsString(),
+    IsOptional(),
+    __metadata("design:type", String)
+], StandaloneConfiguration.prototype, "index", void 0);
+__decorate([
+    IsArray(),
+    IsOptional(),
+    __metadata("design:type", Array)
+], StandaloneConfiguration.prototype, "segments", void 0);

package/dist/server/controllers/AssetsController.d.ts

@@ -0,0 +1,8 @@
+import express from 'express';
+import { Logger } from 'tslog';
+import LocalRepository from '../../runtime/LocalRepository.js';
+import Proxy from '../../runtime/Proxy.js';
+export default class AssetsController {
+    #private;
+    constructor(app: express.Application, repository: LocalRepository | Proxy, indexFile: string, logger: Logger);
+}

package/dist/server/controllers/AssetsController.js

@@ -0,0 +1,50 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Controller } from '@overnightjs/core';
+import express from 'express';
+import { Logger } from 'tslog';
+import FileNotFound from '../../runtime/errors/FileNotFound.js';
+let AssetsController = class AssetsController {
+    #repository;
+    #indexFile;
+    #logger;
+    constructor(app, repository, indexFile, logger) {
+        this.#repository = repository;
+        this.#indexFile = indexFile;
+        this.#logger = logger;
+        app.get('*', (request, response) => { this.#getContent(request, response); });
+    }
+    async #getContent(request, response) {
+        this.#logger.info(`Got asset -> '${request.path}'`);
+        const path = request.path.substring(1).trim();
+        const filename = path.length === 0 ? this.#indexFile : path;
+        try {
+            const file = await this.#repository.loadAsset(filename);
+            response.set('Content-Type', file.type);
+            response.set('Content-Length', String(file.size));
+            response.status(200).send(file.content);
+        }
+        catch (error) {
+            if (error instanceof FileNotFound) {
+                this.#logger.warn(`Failed to get asset -> '${filename}' | ${error.message}`);
+                response.status(404).send(error.message);
+                return;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            this.#logger.error(`Failed to get file content -> '${filename}' | ${message}`);
+            response.status(500).send(message);
+        }
+    }
+};
+AssetsController = __decorate([
+    Controller(''),
+    __metadata("design:paramtypes", [Function, Object, String, Logger])
+], AssetsController);
+export default AssetsController;

package/dist/server/controllers/HealthController.d.ts

@@ -0,0 +1,10 @@
+import { Request, Response } from 'express';
+import { Logger } from 'tslog';
+import LocalNode from '../../runtime/LocalNode.js';
+import Proxy from '../../runtime/Proxy.js';
+export default class HealthController {
+    #private;
+    constructor(node: LocalNode | Proxy, logger: Logger);
+    getHealth(request: Request, response: Response): Promise<Response>;
+    isHealthy(request: Request, response: Response): Promise<Response>;
+}

package/dist/server/controllers/HealthController.js

@@ -0,0 +1,47 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Controller, Get } from '@overnightjs/core';
+import { Logger } from 'tslog';
+let HealthController = class HealthController {
+    #node;
+    #logger;
+    constructor(node, logger) {
+        this.#node = node;
+        this.#logger = logger;
+    }
+    async getHealth(request, response) {
+        const health = await this.#node.getHealth();
+        const data = Object.fromEntries(health);
+        this.#logger.debug('Got health');
+        return response.status(200).send(data);
+    }
+    async isHealthy(request, response) {
+        const healthy = await this.#node.isHealthy();
+        this.#logger.debug('Got health status');
+        return response.status(200).send(healthy);
+    }
+};
+__decorate([
+    Get(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], HealthController.prototype, "getHealth", null);
+__decorate([
+    Get('status'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], HealthController.prototype, "isHealthy", null);
+HealthController = __decorate([
+    Controller('health'),
+    __metadata("design:paramtypes", [Object, Logger])
+], HealthController);
+export default HealthController;

package/dist/server/controllers/JitarController.d.ts

@@ -0,0 +1,4 @@
+import express from 'express';
+export default class JitarController {
+    constructor(app: express.Application);
+}

package/dist/server/controllers/JitarController.js

@@ -0,0 +1,26 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Controller } from '@overnightjs/core';
+import express from 'express';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const filePath = fileURLToPath(import.meta.url);
+const fileLocation = path.dirname(filePath);
+const rootLocation = path.join(fileLocation, '../../');
+let JitarController = class JitarController {
+    constructor(app) {
+        app.use('/jitar', express.static(rootLocation));
+    }
+};
+JitarController = __decorate([
+    Controller(''),
+    __metadata("design:paramtypes", [Function])
+], JitarController);
+export default JitarController;

package/dist/server/controllers/ModulesController.d.ts

@@ -0,0 +1,10 @@
+import { Request, Response } from 'express';
+import { Logger } from 'tslog';
+import LocalRepository from '../../runtime/LocalRepository.js';
+import Proxy from '../../runtime/Proxy.js';
+export default class ModulesController {
+    #private;
+    constructor(repository: LocalRepository | Proxy, logger: Logger);
+    registerClient(request: Request, response: Response): Promise<Response>;
+    getModule(request: Request, response: Response): Promise<Response>;
+}

package/dist/server/controllers/ModulesController.js

@@ -0,0 +1,62 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Controller, Get, Post } from '@overnightjs/core';
+import { Logger } from 'tslog';
+import ValueSerializer from '../../runtime/serialization/ValueSerializer.js';
+let ModulesController = class ModulesController {
+    #repository;
+    #logger;
+    constructor(repository, logger) {
+        this.#repository = repository;
+        this.#logger = logger;
+    }
+    async registerClient(request, response) {
+        const segmentFiles = request.body;
+        const clientId = await this.#repository.registerClient(segmentFiles);
+        this.#logger.info(`Registered client -> ${clientId} [${segmentFiles.join(',')}]`);
+        return response.status(200).send(clientId);
+    }
+    async getModule(request, response) {
+        const clientId = request.params.clientId;
+        const pathKey = `/${clientId}/`;
+        const pathIndex = request.path.indexOf(pathKey) + pathKey.length;
+        const filename = request.path.substring(pathIndex);
+        try {
+            const file = await this.#repository.loadModule(clientId, filename);
+            this.#logger.info(`Got module -> '${filename}' (${clientId})`);
+            response.set('Content-Type', file.type);
+            return response.status(200).send(file.content);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.#logger.error(`Failed to get module -> '${filename}' (${clientId}) | ${message}`);
+            const data = ValueSerializer.serialize(error);
+            response.setHeader('Content-Type', 'application/json');
+            return response.status(500).send(data);
+        }
+    }
+};
+__decorate([
+    Post(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ModulesController.prototype, "registerClient", null);
+__decorate([
+    Get(':clientId/*'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ModulesController.prototype, "getModule", null);
+ModulesController = __decorate([
+    Controller('modules'),
+    __metadata("design:paramtypes", [Object, Logger])
+], ModulesController);
+export default ModulesController;

package/dist/server/controllers/NodesController.d.ts

@@ -0,0 +1,9 @@
+import { Request, Response } from 'express';
+import { Logger } from 'tslog';
+import LocalGateway from '../../runtime/LocalGateway.js';
+export default class NodesController {
+    #private;
+    constructor(gateway: LocalGateway, logger: Logger);
+    getNodes(request: Request, response: Response): Promise<Response>;
+    add(request: Request, response: Response): Promise<Response>;
+}