@kapeta/local-cluster-service 0.16.7 → 0.17.0

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+# [0.17.0](https://github.com/kapetacom/local-cluster-service/compare/v0.16.8...v0.17.0) (2023-09-02)
+
+
+### Bug Fixes
+
+* Bump dependencies ([273a75b](https://github.com/kapetacom/local-cluster-service/commit/273a75b4727cbfc19fa186849a81aebba9b85b00))
+* TS 5.2 is more strict with build options ([d5a27be](https://github.com/kapetacom/local-cluster-service/commit/d5a27bed4d89d1ed557517b5ae9bfcc1dccabbb0))
+
+
+### Features
+
+* Add default provider and sample installations ([#65](https://github.com/kapetacom/local-cluster-service/issues/65)) ([ea4fe89](https://github.com/kapetacom/local-cluster-service/commit/ea4fe899988cbbaeb5a1020517e7e88ac967e6b9))
+
+## [0.16.8](https://github.com/kapetacom/local-cluster-service/compare/v0.16.7...v0.16.8) (2023-08-30)
+
+
+### Bug Fixes
+
+* Gracefully handled instances that have been deleted ([#64](https://github.com/kapetacom/local-cluster-service/issues/64)) ([e26ed35](https://github.com/kapetacom/local-cluster-service/commit/e26ed353e474b7417939008fb1eadec891d5ead9))
+
 ## [0.16.7](https://github.com/kapetacom/local-cluster-service/compare/v0.16.6...v0.16.7) (2023-08-24)
 
 

package/dist/cjs/index.js

@@ -26,6 +26,7 @@ const utils_1 = require("./src/utils/utils");
 const request_1 = __importDefault(require("request"));
 const repositoryManager_1 = require("./src/repositoryManager");
 const commandLineUtils_1 = require("./src/utils/commandLineUtils");
+const DefaultProviderInstaller_1 = require("./src/utils/DefaultProviderInstaller");
 let currentServer = null;
 function createServer() {
     const app = (0, express_1.default)();
@@ -106,6 +107,7 @@ exports.default = {
         catch (e) {
             console.error('Could not ping docker runtime: ' + e.toString() + '. Make sure docker is running and working.');
         }
+        await DefaultProviderInstaller_1.defaultProviderInstaller.checkForDefault();
         const clusterPort = storageService_1.storageService.get('cluster', 'port');
         if (clusterPort) {
             clusterService_1.clusterService.setClusterServicePort(clusterPort);

package/dist/cjs/src/instanceManager.js

@@ -480,6 +480,36 @@ class InstanceManager {
                 if (instance.ref) {
                     instance.ref = (0, utils_1.normalizeKapetaUri)(instance.ref);
                 }
+                if (instance.desiredStatus === types_1.DesiredInstanceStatus.RUN) {
+                    // Check if the plan still exists and the instance is still in the plan
+                    // - and that the block definition exists
+                    try {
+                        const plan = await assetManager_1.assetManager.getAsset(instance.systemId, true, false);
+                        if (!plan) {
+                            instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+                        const planData = plan.data;
+                        const planInstance = planData?.spec?.blocks?.find((b) => b.id === instance.instanceId);
+                        if (!planInstance || !planInstance?.block?.ref) {
+                            instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+                        const blockDef = await assetManager_1.assetManager.getAsset(instance.ref, true, false);
+                        if (!blockDef) {
+                            instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
+                            changed = true;
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        console.warn('Failed to check assets', instance.systemId, e);
+                        instance.desiredStatus = types_1.DesiredInstanceStatus.STOP;
+                        return;
+                    }
+                }
                 const newStatus = await this.requestInstanceStatus(instance);
                 /*
                 console.log('Check instance %s %s: [current: %s, new: %s, desired: %s]',

package/dist/cjs/src/socketManager.js

@@ -34,9 +34,15 @@ class SocketManager {
         return this._io;
     }
     emit(context, type, payload) {
+        if (!this._io) {
+            return;
+        }
         this.io.to(context).emit(type, { context, payload });
     }
     emitGlobal(type, payload) {
+        if (!this._io) {
+            return;
+        }
         this.io.emit(type, payload);
     }
     emitSystemEvent(systemId, type, payload) {

package/dist/cjs/src/utils/DefaultProviderInstaller.d.ts

@@ -0,0 +1,11 @@
+declare class DefaultProviderInstaller {
+    private readonly progressListener;
+    checkForDefault(): Promise<void>;
+    private install;
+    private linkLocal;
+    private scanProjectBase;
+    private ensureDefaultProjectHome;
+    private download;
+}
+export declare const defaultProviderInstaller: DefaultProviderInstaller;
+export {};

package/dist/cjs/src/utils/DefaultProviderInstaller.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultProviderInstaller = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const request_1 = __importDefault(require("request"));
+const tar_stream_1 = require("tar-stream");
+const gunzip_maybe_1 = __importDefault(require("gunzip-maybe"));
+const filesystemManager_1 = require("../filesystemManager");
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const progressListener_1 = require("../progressListener");
+const glob_1 = require("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 {
+    progressListener = new progressListener_1.ProgressListener();
+    async checkForDefault() {
+        const definitions = local_cluster_config_1.default.getDefinitions();
+        if (definitions.length < 1) {
+            console.log('Installing default providers');
+            try {
+                await this.install();
+            }
+            catch (e) {
+                console.warn('Failed to install defaults', e);
+            }
+        }
+    }
+    async install() {
+        await this.download();
+        await this.linkLocal();
+    }
+    async linkLocal() {
+        const projectBase = await this.ensureDefaultProjectHome();
+        const folders = this.scanProjectBase(projectBase);
+        for (let folder of folders) {
+            console.log('Linking %s', folder);
+            await nodejs_registry_utils_1.Actions.link(this.progressListener, folder);
+        }
+    }
+    scanProjectBase(projectBase) {
+        const assetFiles = glob_1.glob.sync('*/**/kapeta.yml', { cwd: projectBase });
+        return assetFiles.map((assetFile) => {
+            return node_path_1.default.dirname(node_path_1.default.join(projectBase, assetFile));
+        });
+    }
+    async ensureDefaultProjectHome() {
+        const defaultProjectHome = node_path_1.default.join(node_os_1.default.homedir(), DEFAULT_PROJECT_HOME_DIR);
+        let projectBase = filesystemManager_1.filesystemManager.getProjectRootFolder();
+        if (!projectBase) {
+            filesystemManager_1.filesystemManager.setProjectRootFolder(defaultProjectHome);
+            projectBase = defaultProjectHome;
+            if (!(await fs_extra_1.default.pathExists(projectBase))) {
+                await fs_extra_1.default.mkdirp(projectBase);
+            }
+        }
+        return projectBase;
+    }
+    async download() {
+        const projectBase = await this.ensureDefaultProjectHome();
+        const repoBase = local_cluster_config_1.default.getRepositoryBasedir();
+        return new Promise((resolve, reject) => {
+            const extractor = (0, tar_stream_1.extract)();
+            const dirCache = new Set();
+            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 = header.name.startsWith(ARCHIVE_LOCAL_PREFIX) ? projectBase : repoBase;
+                const parts = header.name.split(/\//g);
+                parts.shift();
+                const filename = parts.join(node_path_1.default.sep);
+                try {
+                    const dirname = node_path_1.default.join(baseDir, node_path_1.default.dirname(filename));
+                    if (!dirCache.has(dirname)) {
+                        let dirExists = false;
+                        try {
+                            await fs_extra_1.default.stat(dirname);
+                            dirExists = true;
+                        }
+                        catch (e) { }
+                        if (!dirExists) {
+                            await fs_extra_1.default.mkdirp(dirname);
+                        }
+                        dirCache.add(dirname);
+                    }
+                    const fileTarget = node_path_1.default.join(baseDir, filename);
+                    stream.on('error', (err) => {
+                        reject(err);
+                    });
+                    stream.on('end', next);
+                    stream.pipe(fs_extra_1.default.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 = (0, request_1.default)(DEFAULT_PROVIDERS_URL);
+            response.on('error', function (err) {
+                reject(err);
+            });
+            response.pipe((0, gunzip_maybe_1.default)()).pipe(extractor);
+        });
+    }
+}
+exports.defaultProviderInstaller = new DefaultProviderInstaller();

package/dist/esm/index.js

@@ -1,45 +1,51 @@
-import { clusterService } from './src/clusterService';
-import { storageService } from './src/storageService';
-import { serviceManager } from './src/serviceManager';
-import { socketManager } from './src/socketManager';
-import { containerManager } from './src/containerManager';
-import express from 'express';
-import HTTP from 'http';
-import { Server } from 'socket.io';
-import TrafficRoutes from './src/traffic/routes';
-import ProxyRoutes from './src/proxy/routes';
-import ConfigRoutes from './src/config/routes';
-import InstancesRoutes from './src/instances/routes';
-import IdentitiesRoutes from './src/identities/routes';
-import FilesystemRoutes from './src/filesystem/routes';
-import AssetsRoutes from './src/assets/routes';
-import ProviderRoutes from './src/providers/routes';
-import AttachmentRoutes from './src/attachments/routes';
-import TaskRoutes from './src/tasks/routes';
-import APIRoutes from './src/api';
-import { getBindHost } from './src/utils/utils';
-import request from 'request';
-import { repositoryManager } from './src/repositoryManager';
-import { ensureCLI } from './src/utils/commandLineUtils';
+"use strict";
+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 utils_1 = require("./src/utils/utils");
+const request_1 = __importDefault(require("request"));
+const repositoryManager_1 = require("./src/repositoryManager");
+const commandLineUtils_1 = require("./src/utils/commandLineUtils");
+const DefaultProviderInstaller_1 = require("./src/utils/DefaultProviderInstaller");
 let currentServer = null;
 function createServer() {
-    const app = express();
-    app.use('/traffic', TrafficRoutes);
-    app.use('/proxy', ProxyRoutes);
-    app.use('/config', ConfigRoutes);
-    app.use('/instances', InstancesRoutes);
-    app.use('/identities', IdentitiesRoutes);
-    app.use('/files', FilesystemRoutes);
-    app.use('/assets', AssetsRoutes);
-    app.use('/providers', ProviderRoutes);
-    app.use('/attachments', AttachmentRoutes);
-    app.use('/tasks', TaskRoutes);
-    app.use('/api', APIRoutes);
+    const app = (0, express_1.default)();
+    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.get('/status', async (req, res) => {
         res.send({
             ok: true,
-            dockerStatus: await containerManager.checkAlive(),
-            socketStatus: socketManager.isAlive(),
+            dockerStatus: await containerManager_1.containerManager.checkAlive(),
+            socketStatus: socketManager_1.socketManager.isAlive(),
         });
     });
     app.get('/ping', async (req, res) => {
@@ -54,18 +60,18 @@ function createServer() {
             error: 'Unknown',
         });
     });
-    const server = HTTP.createServer(app);
+    const server = http_1.default.createServer(app);
     //socket
-    const io = new Server(server, {
+    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.setIo(io);
+    socketManager_1.socketManager.setIo(io);
     return server;
 }
-export default {
+exports.default = {
     isRunning: function () {
         return !!currentServer;
     },
@@ -77,7 +83,7 @@ export default {
     },
     ping: async function (host, port) {
         return new Promise((resolve, reject) => {
-            request.get(`http://${host}:${port}/ping`, (err, res, body) => {
+            request_1.default.get(`http://${host}:${port}/ping`, (err, res, body) => {
                 if (err) {
                     reject(err);
                     return;
@@ -96,18 +102,19 @@ export default {
         }
         try {
             console.log('Testing docker runtime...');
-            await containerManager.initialize();
+            await containerManager_1.containerManager.initialize();
         }
         catch (e) {
             console.error('Could not ping docker runtime: ' + e.toString() + '. Make sure docker is running and working.');
         }
-        const clusterPort = storageService.get('cluster', 'port');
+        await DefaultProviderInstaller_1.defaultProviderInstaller.checkForDefault();
+        const clusterPort = storageService_1.storageService.get('cluster', 'port');
         if (clusterPort) {
-            clusterService.setClusterServicePort(clusterPort);
+            clusterService_1.clusterService.setClusterServicePort(clusterPort);
         }
-        const clusterHost = storageService.get('cluster', 'host');
+        const clusterHost = storageService_1.storageService.get('cluster', 'host');
         if (clusterHost) {
-            clusterService.setClusterServiceHost(clusterHost);
+            clusterService_1.clusterService.setClusterServiceHost(clusterHost);
         }
         let pingResult = undefined;
         try {
@@ -119,15 +126,15 @@ export default {
         if (pingResult?.ok) {
             throw new Error(`Cluster service already running on: ${clusterHost}:${clusterPort}.`);
         }
-        await clusterService.init();
+        await clusterService_1.clusterService.init();
         currentServer = createServer();
-        const port = clusterService.getClusterServicePort();
-        const host = clusterService.getClusterServiceHost();
+        const port = clusterService_1.clusterService.getClusterServicePort();
+        const host = clusterService_1.clusterService.getClusterServiceHost();
         if (clusterPort !== port) {
-            storageService.put('cluster', 'port', port);
+            storageService_1.storageService.put('cluster', 'port', port);
         }
         if (clusterHost !== host) {
-            storageService.put('cluster', 'host', host);
+            storageService_1.storageService.put('cluster', 'host', host);
         }
         return new Promise(async (resolve, reject) => {
             if (!currentServer) {
@@ -141,22 +148,22 @@ export default {
                 }
                 reject(err);
             });
-            const bindHost = getBindHost(host);
+            const bindHost = (0, utils_1.getBindHost)(host);
             currentServer.listen(port, bindHost, () => {
                 try {
-                    ensureCLI().catch((e) => console.error('Failed to install CLI.', e));
+                    (0, commandLineUtils_1.ensureCLI)().catch((e) => console.error('Failed to install CLI.', e));
                 }
                 catch (e) {
                     console.error('Failed to install CLI.', e);
                 }
                 try {
                     // Start installation process for all default providers
-                    repositoryManager.ensureDefaultProviders();
+                    repositoryManager_1.repositoryManager.ensureDefaultProviders();
                 }
                 catch (e) {
                     console.error('Failed to install default providers.', e);
                 }
-                resolve({ host, port, dockerStatus: containerManager.isAlive() });
+                resolve({ host, port, dockerStatus: containerManager_1.containerManager.isAlive() });
             });
             currentServer.host = host;
             currentServer.port = port;
@@ -177,5 +184,5 @@ export default {
         }
         return Promise.resolve(false);
     },
-    getServices: () => serviceManager.getServices(),
+    getServices: () => serviceManager_1.serviceManager.getServices(),
 };

package/dist/esm/src/RepositoryWatcher.js

@@ -1,14 +1,20 @@
-import chokidar from 'chokidar';
-import ClusterConfiguration from '@kapeta/local-cluster-config';
-import FS from 'fs-extra';
-import Path from 'node:path';
-import YAML from 'yaml';
-import { parseKapetaUri } from '@kapeta/nodejs-utils';
-import _ from 'lodash';
-import { socketManager } from './socketManager';
-import { cacheManager } from './cacheManager';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryWatcher = void 0;
+const chokidar_1 = __importDefault(require("chokidar"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = __importDefault(require("yaml"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const lodash_1 = __importDefault(require("lodash"));
+const socketManager_1 = require("./socketManager");
+const cacheManager_1 = require("./cacheManager");
 const KAPETA_YML_RX = /^kapeta.ya?ml$/;
-export class RepositoryWatcher {
+class RepositoryWatcher {
     watcher;
     disabled = false;
     baseDir;
@@ -16,18 +22,18 @@ export class RepositoryWatcher {
     symbolicLinks = {};
     sourceOfChange = new Map();
     constructor() {
-        this.baseDir = ClusterConfiguration.getRepositoryBasedir();
+        this.baseDir = local_cluster_config_1.default.getRepositoryBasedir();
     }
     setDisabled(disabled) {
         this.disabled = disabled;
     }
     watch() {
-        if (!FS.existsSync(this.baseDir)) {
-            FS.mkdirpSync(this.baseDir);
+        if (!fs_extra_1.default.existsSync(this.baseDir)) {
+            fs_extra_1.default.mkdirpSync(this.baseDir);
         }
-        this.allDefinitions = ClusterConfiguration.getDefinitions();
+        this.allDefinitions = local_cluster_config_1.default.getDefinitions();
         try {
-            this.watcher = chokidar.watch(this.baseDir, {
+            this.watcher = chokidar_1.default.watch(this.baseDir, {
                 followSymlinks: false,
                 ignorePermissionErrors: true,
                 disableGlobbing: true,
@@ -53,7 +59,7 @@ export class RepositoryWatcher {
     async setSourceOfChangeFor(file, source) {
         this.sourceOfChange.set(file, source);
         try {
-            const realPath = await FS.realpath(file);
+            const realPath = await fs_extra_1.default.realpath(file);
             if (realPath !== file) {
                 this.sourceOfChange.set(realPath, source);
             }
@@ -65,7 +71,7 @@ export class RepositoryWatcher {
     async clearSourceOfChangeFor(file) {
         this.sourceOfChange.delete(file);
         try {
-            const realPath = await FS.realpath(file);
+            const realPath = await fs_extra_1.default.realpath(file);
             if (realPath !== file) {
                 this.sourceOfChange.delete(realPath);
             }
@@ -83,10 +89,10 @@ export class RepositoryWatcher {
         this.watcher = undefined;
     }
     async getAssetIdentity(path) {
-        const baseName = Path.basename(path);
+        const baseName = node_path_1.default.basename(path);
         let handle, name, version;
         if (path.startsWith(this.baseDir)) {
-            const relativePath = Path.relative(this.baseDir, path);
+            const relativePath = node_path_1.default.relative(this.baseDir, path);
             // Inside the repo we can use the path to determine the handle, name and version
             [handle, name, version] = relativePath.split(/\//g);
             if (!handle || !name || !version) {
@@ -107,8 +113,8 @@ export class RepositoryWatcher {
         // Version is always 'local'
         version = 'local';
         try {
-            const definition = YAML.parse((await FS.readFile(path)).toString());
-            const uri = parseKapetaUri(definition.metadata.name);
+            const definition = yaml_1.default.parse((await fs_extra_1.default.readFile(path)).toString());
+            const uri = (0, nodejs_utils_1.parseKapetaUri)(definition.metadata.name);
             handle = uri.handle;
             name = uri.name;
             return {
@@ -155,15 +161,15 @@ export class RepositoryWatcher {
         this.sourceOfChange.delete(path);
     }
     async checkForChange(assetIdentity, sourceOfChange) {
-        const ymlPath = Path.join(this.baseDir, assetIdentity.handle, assetIdentity.name, assetIdentity.version, 'kapeta.yml');
-        const newDefinitions = ClusterConfiguration.getDefinitions();
+        const ymlPath = node_path_1.default.join(this.baseDir, assetIdentity.handle, assetIdentity.name, assetIdentity.version, 'kapeta.yml');
+        const newDefinitions = local_cluster_config_1.default.getDefinitions();
         const newDefinition = newDefinitions.find((d) => d.ymlPath === ymlPath);
         let currentDefinition = this.allDefinitions.find((d) => d.ymlPath === ymlPath);
         const ymlExists = await this.exists(ymlPath);
         let type;
         if (ymlExists) {
             if (currentDefinition) {
-                if (newDefinition && _.isEqual(currentDefinition, newDefinition)) {
+                if (newDefinition && lodash_1.default.isEqual(currentDefinition, newDefinition)) {
                     //Definition was not changed
                     return;
                 }
@@ -180,7 +186,7 @@ export class RepositoryWatcher {
         }
         else {
             if (currentDefinition) {
-                const ref = parseKapetaUri(`${currentDefinition.definition.metadata.name}:${currentDefinition.version}`).id;
+                const ref = (0, nodejs_utils_1.parseKapetaUri)(`${currentDefinition.definition.metadata.name}:${currentDefinition.version}`).id;
                 //Something was removed
                 type = 'removed';
             }
@@ -197,12 +203,12 @@ export class RepositoryWatcher {
         };
         this.allDefinitions = newDefinitions;
         //console.log('Asset changed', payload);
-        socketManager.emitGlobal('asset-change', payload);
-        cacheManager.flush();
+        socketManager_1.socketManager.emitGlobal('asset-change', payload);
+        cacheManager_1.cacheManager.flush();
     }
     async exists(path) {
         try {
-            await FS.access(path);
+            await fs_extra_1.default.access(path);
             return true;
         }
         catch (e) {
@@ -228,9 +234,9 @@ export class RepositoryWatcher {
         try {
             // Make sure we're not watching the symlink target
             await this.removeSymlinkTarget(path);
-            const stat = await FS.lstat(path);
+            const stat = await fs_extra_1.default.lstat(path);
             if (stat.isSymbolicLink()) {
-                const realPath = `${await FS.realpath(path)}/kapeta.yml`;
+                const realPath = `${await fs_extra_1.default.realpath(path)}/kapeta.yml`;
                 if (await this.exists(realPath)) {
                     //console.log('Watching symlink target %s => %s', path, realPath);
                     this.watcher?.add(realPath);
@@ -250,13 +256,13 @@ export class RepositoryWatcher {
         if (path.includes('/node_modules/')) {
             return true;
         }
-        const filename = Path.basename(path);
+        const filename = node_path_1.default.basename(path);
         if (filename.startsWith('.')) {
             return true;
         }
-        const relativePath = Path.relative(this.baseDir, path).split(Path.sep);
+        const relativePath = node_path_1.default.relative(this.baseDir, path).split(node_path_1.default.sep);
         try {
-            if (FS.statSync(path).isDirectory()) {
+            if (fs_extra_1.default.statSync(path).isDirectory()) {
                 if (relativePath.length > 3) {
                     return true;
                 }
@@ -270,3 +276,4 @@ export class RepositoryWatcher {
         return !/^kapeta\.ya?ml$/.test(filename);
     }
 }
+exports.RepositoryWatcher = RepositoryWatcher;

package/dist/esm/src/api.js

@@ -1,21 +1,26 @@
-import Router from 'express-promise-router';
-import { corsHandler } from './middleware/cors';
-import { KapetaAPI } from '@kapeta/nodejs-api-client';
-import ClusterConfiguration from '@kapeta/local-cluster-config';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const cors_1 = require("./middleware/cors");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
 const { createAPIRoute } = require('@kapeta/web-microfrontend/server');
 const packageJson = require('../package.json');
-const router = Router();
-const remoteServices = ClusterConfiguration.getClusterConfig().remoteServices ?? {};
-router.use('/', corsHandler);
+const router = (0, express_promise_router_1.default)();
+const remoteServices = local_cluster_config_1.default.getClusterConfig().remoteServices ?? {};
+router.use('/', cors_1.corsHandler);
 router.use('/registry', createAPIRoute(remoteServices.registry ?? 'https://registry.kapeta.com', {
     nonce: false,
     userAgent: `KapetaDesktopCluster/${packageJson.version}`,
     tokenFetcher: () => {
-        const api = new KapetaAPI();
+        const api = new nodejs_api_client_1.KapetaAPI();
         if (api.hasToken()) {
             return api.getAccessToken();
         }
         return null;
     },
 }));
-export default router;
+exports.default = router;