@kapeta/local-cluster-service 0.16.8 → 0.17.0

package/dist/esm/src/utils/LogData.js

@@ -1,5 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogData = void 0;
 const MAX_LINES = 1000;
-export class LogData {
+class LogData {
     static MAX_LINES = MAX_LINES;
     entries = [];
     constructor() { }
@@ -36,3 +39,4 @@ export class LogData {
             .join('\n');
     }
 }
+exports.LogData = LogData;

package/dist/esm/src/utils/commandLineUtils.js

@@ -1,14 +1,18 @@
-import { spawn, hasApp } from '@kapeta/nodejs-process';
-import { taskManager } from '../taskManager';
-export async function hasCLI() {
-    return hasApp('kap');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureCLI = exports.hasCLI = void 0;
+const nodejs_process_1 = require("@kapeta/nodejs-process");
+const taskManager_1 = require("../taskManager");
+async function hasCLI() {
+    return (0, nodejs_process_1.hasApp)('kap');
 }
-export async function ensureCLI() {
+exports.hasCLI = hasCLI;
+async function ensureCLI() {
     if (await hasCLI()) {
         return null;
     }
-    return taskManager.add(`cli:install`, () => {
-        const process = spawn('npm', ['install', '-g', '@kapeta/kap'], {
+    return taskManager_1.taskManager.add(`cli:install`, () => {
+        const process = (0, nodejs_process_1.spawn)('npm', ['install', '-g', '@kapeta/kap'], {
             shell: true,
         });
         return process.wait();
@@ -16,3 +20,4 @@ export async function ensureCLI() {
         name: `Installing Kapeta CLI`,
     });
 }
+exports.ensureCLI = ensureCLI;

package/dist/esm/src/utils/pathTemplateParser.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathTemplateParser = exports.PathTemplate = void 0;
 const TYPE_VARIABLE = 'variable';
 const TYPE_PATH = 'path';
 /**
@@ -11,7 +14,7 @@ const TYPE_PATH = 'path';
  *  /foo/{bar:[0-9]+}/baz
  *
  */
-export class PathTemplate {
+class PathTemplate {
     _path;
     _parts = [];
     constructor(pathTemplate) {
@@ -108,9 +111,11 @@ export class PathTemplate {
         return 'tmpl: ' + this.path;
     }
 }
+exports.PathTemplate = PathTemplate;
 /**
  * Parses a path into a RESTPath
  */
-export function pathTemplateParser(path) {
+function pathTemplateParser(path) {
     return new PathTemplate(path);
 }
+exports.pathTemplateParser = pathTemplateParser;

package/dist/esm/src/utils/utils.js

@@ -1,40 +1,53 @@
-import FS from 'node:fs';
-import YAML from 'yaml';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import md5 from 'md5';
-export function getBlockInstanceContainerName(systemId, instanceId) {
-    return `kapeta-block-instance-${md5(systemId + instanceId)}`;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.normalizeKapetaUri = exports.getBlockInstanceContainerName = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const yaml_1 = __importDefault(require("yaml"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const md5_1 = __importDefault(require("md5"));
+function getBlockInstanceContainerName(systemId, instanceId) {
+    return `kapeta-block-instance-${(0, md5_1.default)(systemId + instanceId)}`;
 }
-export function normalizeKapetaUri(uri) {
+exports.getBlockInstanceContainerName = getBlockInstanceContainerName;
+function normalizeKapetaUri(uri) {
     if (!uri) {
         return '';
     }
-    const uriObj = parseKapetaUri(uri);
+    const uriObj = (0, nodejs_utils_1.parseKapetaUri)(uri);
     if (!uriObj.version) {
-        return `kapeta://${parseKapetaUri(uri).fullName}`;
+        return `kapeta://${(0, nodejs_utils_1.parseKapetaUri)(uri).fullName}`;
     }
-    return `kapeta://${parseKapetaUri(uri).id}`;
+    return `kapeta://${(0, nodejs_utils_1.parseKapetaUri)(uri).id}`;
 }
-export function readYML(path) {
-    const rawYaml = FS.readFileSync(path);
+exports.normalizeKapetaUri = normalizeKapetaUri;
+function readYML(path) {
+    const rawYaml = node_fs_1.default.readFileSync(path);
     try {
-        return YAML.parse(rawYaml.toString());
+        return yaml_1.default.parse(rawYaml.toString());
     }
     catch (err) {
         throw new Error(`Failed to parse plan YAML: ${err}`);
     }
 }
-export function isWindows() {
+exports.readYML = readYML;
+function isWindows() {
     return 'win32' === process.platform;
 }
-export function isMac() {
+exports.isWindows = isWindows;
+function isMac() {
     return 'darwin' === process.platform;
 }
-export function isLinux() {
+exports.isMac = isMac;
+function isLinux() {
     return !isWindows() && !isMac();
 }
-export function getBindHost(preferredHost = '127.0.0.1') {
+exports.isLinux = isLinux;
+function getBindHost(preferredHost = '127.0.0.1') {
     // 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.
     return isLinux() ? '0.0.0.0' : preferredHost;
 }
+exports.getBindHost = getBindHost;

package/dist/esm/start.js

@@ -1,5 +1,10 @@
-import localClusterService from './index';
-localClusterService
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("./index"));
+index_1.default
     .start()
     .then(({ host, port }) => console.log('Listening on port %s:%s', host, port))
     .catch((e) => {

package/index.ts

@@ -22,6 +22,7 @@ import { getBindHost } from './src/utils/utils';
 import request from 'request';
 import { repositoryManager } from './src/repositoryManager';
 import { ensureCLI } from './src/utils/commandLineUtils';
+import { defaultProviderInstaller } from './src/utils/DefaultProviderInstaller';
 
 export type LocalClusterService = HTTP.Server & { host?: string; port?: number };
 
@@ -122,6 +123,8 @@ export default {
             );
         }
 
+        await defaultProviderInstaller.checkForDefault();
+
         const clusterPort = storageService.get('cluster', 'port');
         if (clusterPort) {
             clusterService.setClusterServicePort(clusterPort);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.16.8",
+    "version": "0.17.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -34,8 +34,8 @@
         "dev": "nodemon -e js,ts,json ./start.ts",
         "test": "echo its fine",
         "clean": "rm -rf ./dist",
-        "build:esm": "tsc --module esnext --outDir ./dist/esm && echo '{\"type\":\"module\"}' > ./dist/esm/package.json",
-        "build:cjs": "tsc --module commonjs --outDir ./dist/cjs && echo '{\"type\":\"commonjs\"}' > ./dist/cjs/package.json",
+        "build:esm": "tsc --module nodenext --moduleResolution nodenext --outDir ./dist/esm && echo '{\"type\":\"module\"}' > ./dist/esm/package.json",
+        "build:cjs": "tsc  --outDir ./dist/cjs && echo '{\"type\":\"commonjs\"}' > ./dist/cjs/package.json",
         "build": "npm run clean && npm run build:esm && npm run build:cjs",
         "format": "prettier --write .",
         "lint": "tsc --noEmit && eslint src/**/*.ts",
@@ -57,7 +57,8 @@
         "express": "4.17.1",
         "express-promise-router": "^4.1.1",
         "fs-extra": "^11.1.0",
-        "glob": "7.1.6",
+        "glob": "^7.1.6",
+        "gunzip-maybe": "^1.4.2",
         "lodash": "^4.17.15",
         "md5": "2.2.1",
         "node-cache": "^5.1.2",
@@ -66,6 +67,7 @@
         "request": "2.88.2",
         "request-promise": "4.2.6",
         "socket.io": "^4.5.2",
+        "tar-stream": "^3.1.6",
         "typescript": "^5.1.6",
         "yaml": "^1.6.0"
     },
@@ -76,10 +78,14 @@
         "@types/async-lock": "^1.4.0",
         "@types/express": "^4.17.17",
         "@types/fs-extra": "^11.0.1",
+        "@types/glob": "^8.1.0",
+        "@types/gunzip-maybe": "^1.4.0",
         "@types/lodash": "^4.14.195",
         "@types/md5": "^2.3.2",
+        "@types/node": "^20.5.8",
         "@types/node-uuid": "^0.0.29",
         "@types/request": "^2.48.8",
+        "@types/tar-stream": "^2.2.2",
         "eslint": "^8.42.0",
         "eslint-config-prettier": "^8.8.0",
         "nodemon": "^2.0.2",

package/src/instanceManager.ts

@@ -22,7 +22,7 @@ const DEFAULT_HEALTH_PORT_TYPE = 'rest';
 const MIN_TIME_RUNNING = 30000; //If something didnt run for more than 30 secs - it failed
 
 export class InstanceManager {
-    private _interval: NodeJS.Timer | undefined = undefined;
+    private _interval: any = undefined;
 
     private readonly _instances: InstanceInfo[] = [];
 

package/src/socketManager.ts

@@ -37,10 +37,16 @@ export class SocketManager {
     }
 
     emit(context: string, type: string, payload: any) {
+        if (!this._io) {
+            return;
+        }
         this.io.to(context).emit(type, { context, payload });
     }
 
     emitGlobal(type: string, payload: any) {
+        if (!this._io) {
+            return;
+        }
         this.io.emit(type, payload);
     }
 

package/src/utils/DefaultProviderInstaller.ts

@@ -0,0 +1,141 @@
+import Path from 'node:path';
+import OS from 'node:os';
+import ClusterConfiguration from '@kapeta/local-cluster-config';
+import FS from 'fs-extra';
+import request from 'request';
+import { extract } from 'tar-stream';
+import gunzip from 'gunzip-maybe';
+import { filesystemManager } from '../filesystemManager';
+import { Actions } from '@kapeta/nodejs-registry-utils';
+import { ProgressListener } from '../progressListener';
+import { glob } from 'glob';
+
+const DEFAULT_PROVIDERS_URL = 'https://storage.googleapis.com/kapeta-production-cdn/archives/default-providers.tar.gz';
+const DEFAULT_PROJECT_HOME_DIR = 'KapetaProjects';
+
+const ARCHIVE_LOCAL_PREFIX = 'local';
+
+class DefaultProviderInstaller {
+    private readonly progressListener = new ProgressListener();
+
+    public async checkForDefault() {
+        const definitions = ClusterConfiguration.getDefinitions();
+        if (definitions.length < 1) {
+            console.log('Installing default providers');
+            try {
+                await this.install();
+            } catch (e) {
+                console.warn('Failed to install defaults', e);
+            }
+        }
+    }
+
+    private async install() {
+        await this.download();
+        await this.linkLocal();
+    }
+
+    private async linkLocal() {
+        const projectBase = await this.ensureDefaultProjectHome();
+        const folders = this.scanProjectBase(projectBase);
+        for (let folder of folders) {
+            console.log('Linking %s', folder);
+            await Actions.link(this.progressListener, folder);
+        }
+    }
+
+    private scanProjectBase(projectBase: string) {
+        const assetFiles = glob.sync('*/**/kapeta.yml', { cwd: projectBase });
+        return assetFiles.map((assetFile) => {
+            return Path.dirname(Path.join(projectBase, assetFile));
+        });
+    }
+
+    private async ensureDefaultProjectHome(): Promise<string> {
+        const defaultProjectHome = Path.join(OS.homedir(), DEFAULT_PROJECT_HOME_DIR);
+        let projectBase = filesystemManager.getProjectRootFolder();
+
+        if (!projectBase) {
+            filesystemManager.setProjectRootFolder(defaultProjectHome);
+            projectBase = defaultProjectHome;
+            if (!(await FS.pathExists(projectBase))) {
+                await FS.mkdirp(projectBase);
+            }
+        }
+        return projectBase;
+    }
+
+    private async download() {
+        const projectBase: string = await this.ensureDefaultProjectHome();
+        const repoBase: string = ClusterConfiguration.getRepositoryBasedir();
+
+        return new Promise<void>((resolve, reject) => {
+            const extractor = extract();
+            const dirCache = new Set<string>();
+            extractor.on('entry', async function (header, stream, next) {
+                if (header.type !== 'file') {
+                    stream.on('end', function () {
+                        next(); // ready for next entry
+                    });
+                    stream.resume(); // just auto drain the stream
+                    return;
+                }
+
+                // Local (editable) assets should be stored in the project folder
+                // - installed assets goes into the repository folder
+                const baseDir: string = header.name.startsWith(ARCHIVE_LOCAL_PREFIX) ? projectBase : repoBase;
+
+                const parts = header.name.split(/\//g);
+                parts.shift();
+                const filename = parts.join(Path.sep);
+
+                try {
+                    const dirname = Path.join(baseDir, Path.dirname(filename));
+                    if (!dirCache.has(dirname)) {
+                        let dirExists = false;
+                        try {
+                            await FS.stat(dirname);
+                            dirExists = true;
+                        } catch (e) {}
+                        if (!dirExists) {
+                            await FS.mkdirp(dirname);
+                        }
+                        dirCache.add(dirname);
+                    }
+                    const fileTarget = Path.join(baseDir, filename);
+                    stream.on('error', (err) => {
+                        reject(err);
+                    });
+                    stream.on('end', next);
+
+                    stream.pipe(
+                        FS.createWriteStream(fileTarget, {
+                            mode: header.mode,
+                        })
+                    );
+                } catch (e) {
+                    reject(e);
+                }
+            });
+
+            extractor.on('finish', function () {
+                // all entries done - lets finalize it
+                console.log('Default providers installed');
+                resolve();
+            });
+
+            extractor.on('error', function (err) {
+                reject(err);
+            });
+
+            console.log('Downloading default providers from %s', DEFAULT_PROVIDERS_URL);
+            const response = request(DEFAULT_PROVIDERS_URL);
+            response.on('error', function (err) {
+                reject(err);
+            });
+            response.pipe(gunzip()).pipe(extractor);
+        });
+    }
+}
+
+export const defaultProviderInstaller = new DefaultProviderInstaller();

package/tsconfig.json

@@ -1,9 +1,10 @@
 {
     "extends": "@tsconfig/node18/tsconfig.json",
     "compilerOptions": {
+        "module": "node16",
+        "moduleResolution": "node16",
         "outDir": "./dist",
-        "declaration": true,
-        "esModuleInterop": true
+        "declaration": true
     },
     "ts-node": {
         "files": true