@kapeta/local-cluster-service 0.0.0-96f91ef

package/dist/cjs/test/proxy/types/rest.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export {};

package/dist/cjs/test/proxy/types/rest.test.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const rest_1 = require("../../../src/proxy/types/rest");
+describe('getRestMethodId', () => {
+    it('should match @Query in url', () => {
+        const restResource = new TestResource();
+        const restMethodId = (0, rest_1.getRestMethodId)(restResource, 'POST', '/names?name=Ib');
+        expect(restMethodId).toBeDefined();
+    });
+});
+class TestResource {
+    kind = '';
+    metadata = new TestResourceMetaData();
+    get spec() {
+        return {
+            methods: [
+                {
+                    responseType: {
+                        ref: 'Name[]',
+                    },
+                    method: 'GET',
+                    path: '/names',
+                    arguments: {},
+                },
+                {
+                    responseType: {
+                        ref: 'Name',
+                    },
+                    method: 'POST',
+                    path: '/names',
+                    arguments: {
+                        name: {
+                            type: 'string',
+                            transport: 'QUERY',
+                        },
+                    },
+                },
+            ],
+        };
+    }
+}
+class TestResourceMetaData {
+    name = '';
+}

package/dist/cjs/test/utils/pathTemplateParser.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export {};

package/dist/cjs/test/utils/pathTemplateParser.test.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const pathTemplateParser_1 = require("../../src/utils/pathTemplateParser");
+describe('pathTemplateParser', () => {
+    it('must return parameters for query parameters from parse', () => {
+        const template = new pathTemplateParser_1.PathTemplate('/names');
+        const parse = template.parse('/names?name=Ib#test');
+        console.log(parse);
+        expect(parse).toBeTruthy();
+    });
+    it('must return parameters defined in url', () => {
+        const template = new pathTemplateParser_1.PathTemplate('/names/{identityId}');
+        const parse = template.parse('/names/idn_xxyyzz');
+        expect(parse).toBeTruthy();
+        expect(parse).toMatchObject({ identityId: 'idn_xxyyzz' });
+    });
+    it('must return parameters defined in url regardless of query parameters', () => {
+        const template = new pathTemplateParser_1.PathTemplate('/names/{identityId}');
+        const parse = template.parse('/names/idn_xxyyzz?name=Ib#test');
+        expect(parse).toBeTruthy();
+        expect(parse).toMatchObject({ identityId: 'idn_xxyyzz' });
+    });
+});

package/dist/esm/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="node" />
+import HTTP from 'http';
+export type LocalClusterService = HTTP.Server & {
+    host?: string;
+    port?: number;
+};
+export type StartResult = {
+    host: string;
+    port: number;
+    dockerStatus: boolean;
+};
+declare const _default: {
+    isRunning: () => boolean;
+    getCurrentPort: () => number | undefined;
+    ping: (host: string, port: number) => Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Starts the local cluster service.
+     * resolves when listening is done with port number. Rejects if listening failed.
+     */
+    start: () => Promise<StartResult>;
+    /**
+     * Stops any currently running cluster services.
+     * @return {Promise<boolean>} Returns true if the service was stopped - false if no service was running.
+     */
+    stop: () => Promise<unknown>;
+    getServices: () => any;
+};
+export default _default;

package/dist/esm/index.js

@@ -0,0 +1,263 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const clusterService_1 = require("./src/clusterService");
+const storageService_1 = require("./src/storageService");
+const serviceManager_1 = require("./src/serviceManager");
+const socketManager_1 = require("./src/socketManager");
+const containerManager_1 = require("./src/containerManager");
+const express_1 = __importDefault(require("express"));
+const http_1 = __importDefault(require("http"));
+const socket_io_1 = require("socket.io");
+const routes_1 = __importDefault(require("./src/traffic/routes"));
+const routes_2 = __importDefault(require("./src/proxy/routes"));
+const routes_3 = __importDefault(require("./src/config/routes"));
+const routes_4 = __importDefault(require("./src/instances/routes"));
+const routes_5 = __importDefault(require("./src/identities/routes"));
+const routes_6 = __importDefault(require("./src/filesystem/routes"));
+const routes_7 = __importDefault(require("./src/assets/routes"));
+const routes_8 = __importDefault(require("./src/providers/routes"));
+const routes_9 = __importDefault(require("./src/attachments/routes"));
+const routes_10 = __importDefault(require("./src/tasks/routes"));
+const api_1 = __importDefault(require("./src/api"));
+const routes_11 = __importDefault(require("./src/ai/routes"));
+const utils_1 = require("./src/utils/utils");
+const request_1 = __importDefault(require("request"));
+const repositoryManager_1 = require("./src/repositoryManager");
+const taskManager_1 = require("./src/taskManager");
+const commandLineUtils_1 = require("./src/utils/commandLineUtils");
+const DefaultProviderInstaller_1 = require("./src/utils/DefaultProviderInstaller");
+const authManager_1 = require("./src/authManager");
+const codeGeneratorManager_1 = require("./src/codeGeneratorManager");
+const Sentry = __importStar(require("@sentry/node"));
+const assetManager_1 = require("./src/assetManager");
+Sentry.init({
+    dsn: 'https://0b7cc946d82c591473d6f95fff5e210b@o4505820837249024.ingest.sentry.io/4506212692000768',
+    enabled: process.env.NODE_ENV !== 'development',
+    // Performance Monitoring on every ~20th request
+    tracesSampleRate: 0.05,
+    // Set sampling rate for profiling - this is relative to tracesSampleRate
+    profilesSampleRate: 1.0,
+});
+let currentServer = null;
+function createServer() {
+    const app = (0, express_1.default)();
+    Sentry.addIntegration(new Sentry.Integrations.Http({ tracing: true }));
+    Sentry.addIntegration(new Sentry.Integrations.Express({ app }));
+    // This causes node < 20 to crash on request.
+    //app.use(Sentry.Handlers.requestHandler());
+    // TracingHandler creates a trace for every incoming request
+    app.use(Sentry.Handlers.tracingHandler());
+    app.use('/traffic', routes_1.default);
+    app.use('/proxy', routes_2.default);
+    app.use('/config', routes_3.default);
+    app.use('/instances', routes_4.default);
+    app.use('/identities', routes_5.default);
+    app.use('/files', routes_6.default);
+    app.use('/assets', routes_7.default);
+    app.use('/providers', routes_8.default);
+    app.use('/attachments', routes_9.default);
+    app.use('/tasks', routes_10.default);
+    app.use('/api', api_1.default);
+    app.use('/ai', routes_11.default);
+    app.get('/status', async (req, res) => {
+        res.send({
+            ok: true,
+            dockerStatus: await containerManager_1.containerManager.checkAlive(),
+            socketStatus: socketManager_1.socketManager.isAlive(),
+        });
+    });
+    app.get('/ping', async (req, res) => {
+        res.send({
+            ok: true,
+        });
+    });
+    app.use('/', (req, res) => {
+        console.error('Invalid request: %s %s', req.method, req.originalUrl);
+        res.status(400).json({
+            ok: false,
+            error: 'Unknown',
+        });
+    });
+    app.use(Sentry.Handlers.errorHandler());
+    /**
+     * Central error handler, allows us to return a consistent JSON response wrapper with the error.
+     */
+    app.use((err, req, res, next) => {
+        console.error('Error handling request: %s %s', req.method, req.originalUrl, err);
+        res.status(err.status || 500).json({
+            ok: false,
+            error: err.message || 'Unknown error',
+            stack: process.env.NODE_ENV !== 'production' ? err.stack : undefined,
+        });
+    });
+    const server = http_1.default.createServer(app);
+    //socket
+    const io = new socket_io_1.Server(server, {
+        cors: {
+            //TODO: This should'nt be hardcoded but also shouldn't be "*"
+            origin: 'http://localhost:8080',
+        },
+    });
+    socketManager_1.socketManager.setIo(io);
+    return server;
+}
+exports.default = {
+    isRunning: function () {
+        return !!currentServer;
+    },
+    getCurrentPort: function () {
+        if (!currentServer) {
+            return -1;
+        }
+        return currentServer.port;
+    },
+    ping: async function (host, port) {
+        return new Promise((resolve, reject) => {
+            request_1.default.get(`http://${host}:${port}/ping`, (err, res, body) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(JSON.parse(body));
+            });
+        });
+    },
+    /**
+     * Starts the local cluster service.
+     * resolves when listening is done with port number. Rejects if listening failed.
+     */
+    start: async function () {
+        if (currentServer) {
+            throw new Error('Server already started');
+        }
+        try {
+            console.log('Testing docker runtime...');
+            await containerManager_1.containerManager.initialize();
+        }
+        catch (e) {
+            console.error('Could not ping docker runtime: ' + e.toString() + '. Make sure docker is running and working.');
+        }
+        await DefaultProviderInstaller_1.defaultProviderInstaller.checkForDefault();
+        await codeGeneratorManager_1.codeGeneratorManager.initialize();
+        const clusterPort = storageService_1.storageService.get('cluster', 'port');
+        if (clusterPort) {
+            clusterService_1.clusterService.setClusterServicePort(clusterPort);
+        }
+        const clusterHost = storageService_1.storageService.get('cluster', 'host');
+        if (clusterHost) {
+            clusterService_1.clusterService.setClusterServiceHost(clusterHost);
+        }
+        let pingResult = undefined;
+        try {
+            pingResult = await this.ping(clusterHost, clusterPort);
+        }
+        catch (e) {
+            //Ignore - expected to not be running since we're starting it
+        }
+        if (pingResult?.ok) {
+            throw new Error(`Cluster service already running on: ${clusterHost}:${clusterPort}.`);
+        }
+        await clusterService_1.clusterService.init();
+        authManager_1.authManager.listenForChanges();
+        currentServer = createServer();
+        const port = clusterService_1.clusterService.getClusterServicePort();
+        const host = clusterService_1.clusterService.getClusterServiceHost();
+        if (clusterPort !== port) {
+            storageService_1.storageService.put('cluster', 'port', port);
+        }
+        if (clusterHost !== host) {
+            storageService_1.storageService.put('cluster', 'host', host);
+        }
+        return new Promise((resolve, reject) => {
+            if (!currentServer) {
+                reject(new Error(`Current server wasn't set`));
+                return;
+            }
+            currentServer.once('error', (err) => {
+                if (currentServer) {
+                    currentServer.close();
+                    currentServer = null;
+                }
+                reject(err);
+            });
+            // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
+            // TODO: This might pose a security risk - so we should authenticate all requests using a
+            //       shared secret/nonce that we pass around.
+            const bindHost = (0, utils_1.isLinux)() ? '0.0.0.0' : host;
+            currentServer.listen(port, bindHost, async () => {
+                try {
+                    const ensureCLITask = await (0, commandLineUtils_1.ensureCLI)();
+                    if (ensureCLITask) {
+                        await taskManager_1.taskManager.waitFor((t) => t === ensureCLITask);
+                    }
+                }
+                catch (e) {
+                    console.error('Failed to install CLI.', e);
+                }
+                try {
+                    await (0, commandLineUtils_1.ensureCLICommands)();
+                }
+                catch (error) {
+                    console.error('Failed to ensure default CLI commands', error);
+                }
+                try {
+                    // Start installation process for all default providers
+                    await repositoryManager_1.repositoryManager.ensureDefaultProviders();
+                }
+                catch (e) {
+                    console.error('Failed to install default providers.', e);
+                }
+                assetManager_1.assetManager.startUpgradeInterval();
+                resolve({ host, port, dockerStatus: containerManager_1.containerManager.isAlive() });
+            });
+            currentServer.host = host;
+            currentServer.port = port;
+        });
+    },
+    /**
+     * Stops any currently running cluster services.
+     * @return {Promise<boolean>} Returns true if the service was stopped - false if no service was running.
+     */
+    stop: function () {
+        if (currentServer) {
+            return new Promise(function (resolve) {
+                if (currentServer) {
+                    currentServer.close(() => resolve(true));
+                    currentServer = null;
+                }
+            });
+        }
+        return Promise.resolve(false);
+    },
+    getServices: () => serviceManager_1.serviceManager.getServices(),
+};

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/src/RepositoryWatcher.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="node" />
+import { SourceOfChange } from './types';
+import { EventEmitter } from 'node:events';
+export declare class RepositoryWatcher extends EventEmitter {
+    private watcher?;
+    private disabled;
+    private readonly baseDir;
+    private allDefinitions;
+    private symbolicLinks;
+    private sourceOfChange;
+    constructor();
+    setDisabled(disabled: boolean): void;
+    watch(): void;
+    setSourceOfChangeFor(file: string, source: SourceOfChange): Promise<void>;
+    clearSourceOfChangeFor(file: string): Promise<void>;
+    unwatch(): Promise<void>;
+    private getAssetIdentity;
+    private handleFileChange;
+    private getRepositoryPath;
+    private checkForChange;
+    private exists;
+    private removeSymlinkTarget;
+    private updateSymlinkTarget;
+    private addSymlinkTarget;
+    private ignoreFile;
+}