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

package/LICENSE

@@ -0,0 +1,38 @@
+License text copyright © 2023 MariaDB plc, All Rights Reserved. “Business Source License” is a trademark of MariaDB plc.
+
+Licensor: Kapeta Inc.
+
+Licensed Work: The Licensed Work is (c) 2023 Kapeta Inc.
+
+Change Date: Four years from the date the Licensed Work is published
+
+Change License: AGPLv1
+
+Updated: Oct. 30, 2023
+
+For information about alternative licensing arrangements for the Licensed Work, please contact licensing@kapeta.com.
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative works, redistribute, and make
+non-production use of the Licensed Work. The Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+Effective on the Change Date, or the fourth anniversary of the first publicly available distribution of a specific
+version of the Licensed Work under this License, whichever comes first, the Licensor hereby grants you rights under the
+terms of the Change License, and the rights granted in the paragraph above terminate.
+If your use of the Licensed Work does not comply with the requirements currently in effect as described in this License,
+you must purchase a commercial license from the Licensor, its affiliated entities, or authorized resellers, or you must
+refrain from using the Licensed Work.
+All copies of the original and modified Licensed Work, and derivative works of the Licensed Work, are subject to this
+License. This License applies separately for each version of the Licensed Work and the Change Date may vary for each
+version of the Licensed Work released by Licensor.
+You must conspicuously display this License on each original or modified copy of the Licensed Work. If you receive the
+Licensed Work in original or modified form from a third party, the terms and conditions set forth in this License apply
+to your use of that work.
+Any use of the Licensed Work in violation of this License will automatically terminate your rights under this License
+for the current and all other versions of the Licensed Work.
+This License does not grant you any right in any trademark or logo of Licensor or its affiliates (provided that you may
+use a trademark or logo of Licensor as expressly required by this License).
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS
+ALL WARRANTIES AND CONDITIONS, EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND TITLE.

package/README.md

@@ -0,0 +1,36 @@
+## Local cluster service for Kapeta
+
+This service is a multi-functional service for simulating a "real" cluster - specifically during
+local development.
+
+### Features
+
+#### Configuration Service
+Provides configuration management for local services to simplify configuring local instances and
+also auto-generates configuration as part of its service discovery and routing capabilities.
+
+#### Service Discovery
+Also provides simple service-discovery through its control over configuration - by simply controlling
+where services find other services. This is also how it injects itself as a MITM proxy for all local 
+traffic and how we intend to achieve "local -> remote" and "remote -> local" tunneling in the future.  
+
+#### Local Proxy
+The service also provides a local proxy server that enables fine-grained routing and traffic-inspection.
+The only protocol currently supported is HTTP and REST-JSON but the intention is to add support for 
+several others such as MySQL, PostgreSQL, MongoDB, Redis and more.  
+
+#### Local Metrics (Not implemented)
+The local cluster service should also support metrics reporting from the 
+local instances to make testing and checking metrics for your local environment straight-forward.
+
+#### Remote Tunnel (Not implemented)
+It's able to connect to a remote cluster and override certain endpoints conditionally in that cluster to
+make them point to itself.
+
+This is to allow these scenarios:
+- Testing in production for a subset of users (Or just your own)
+- Development against a team or private sandbox to avoid running every service locally 
+
+## License
+
+This project is licensed under the BUSL-1.1 License - see the [LICENSE](LICENSE) file for details

package/definitions.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+declare module 'recursive-watch' {
+    export default function watch(path: string, callback: (filename: string) => void): () => void;
+}
+
+declare module '@kapeta/nodejs-registry-utils' {
+    import { Dependency, Kind } from '@kapeta/schemas';
+
+    export interface AssetVersion {
+        content: Kind;
+        dependencies: Dependency[];
+        version: string;
+    }
+
+    export class RegistryService {
+        constructor(url: string);
+
+        getVersion(fullName: string, version: string): Promise<AssetVersion>;
+        getLatestVersion(name): Promise<AssetVersion>;
+    }
+
+    export const Config: any;
+    export const Actions: any;
+
+    export const handlers: {
+        DockerHandler: ArtifactHandlerFactory;
+        NPMHandler: ArtifactHandlerFactory;
+        MavenHandler: ArtifactHandlerFactory;
+        YAMLHandler: ArtifactHandlerFactory;
+    };
+}

package/dist/cjs/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/cjs/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/cjs/package.json

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

package/dist/cjs/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;
+}