@kapeta/local-cluster-service 0.16.8 → 0.18.0

package/dist/cjs/src/repositoryManager.d.ts

@@ -12,8 +12,8 @@ declare class RepositoryManager {
      */
     setSourceOfChangeFor(file: string, source: SourceOfChange): Promise<void>;
     clearSourceOfChangeFor(file: string): Promise<void>;
-    ensureDefaultProviders(): void;
-    private _install;
+    ensureDefaultProviders(): Promise<void>;
+    private scheduleInstallation;
     ensureAsset(handle: string, name: string, version: string, wait?: boolean): Promise<undefined | Task[]>;
 }
 export declare const repositoryManager: RepositoryManager;

package/dist/cjs/src/repositoryManager.js

@@ -53,18 +53,18 @@ class RepositoryManager {
     clearSourceOfChangeFor(file) {
         return this.watcher.clearSourceOfChangeFor(file);
     }
-    ensureDefaultProviders() {
+    async ensureDefaultProviders() {
         socketManager_1.socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
-        const tasks = this._install(DEFAULT_PROVIDERS);
+        const tasks = await this.scheduleInstallation(DEFAULT_PROVIDERS);
         Promise.allSettled(tasks.map((t) => t.wait())).then(() => {
             socketManager_1.socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_END, {});
         });
     }
-    _install(refs) {
+    async scheduleInstallation(refs) {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
         const createInstaller = (ref) => {
             return async () => {
-                if (definitionsManager_1.definitionsManager.exists(ref)) {
+                if (await definitionsManager_1.definitionsManager.exists(ref)) {
                     return;
                 }
                 //console.log(`Installing asset: ${ref}`);
@@ -89,7 +89,7 @@ class RepositoryManager {
                 continue;
             }
             ref = (0, utils_1.normalizeKapetaUri)(ref);
-            if (definitionsManager_1.definitionsManager.exists(ref)) {
+            if (await definitionsManager_1.definitionsManager.exists(ref)) {
                 continue;
             }
             const task = taskManager_1.taskManager.add(`asset:install:${ref}`, createInstaller(ref), {
@@ -107,8 +107,7 @@ class RepositoryManager {
             //TODO: Get dependencies for local asset
             return;
         }
-        const definitions = definitionsManager_1.definitionsManager.getDefinitions();
-        const installedAsset = definitions.find((d) => d.definition.metadata.name === fullName && d.version === version);
+        const installedAsset = await definitionsManager_1.definitionsManager.getDefinition(`${fullName}:${version}`);
         let assetVersion;
         try {
             assetVersion = await this._registryService.getVersion(fullName, version);
@@ -125,13 +124,13 @@ class RepositoryManager {
         }
         let tasks = undefined;
         if (!installedAsset) {
-            tasks = this._install([ref]);
+            tasks = await this.scheduleInstallation([ref]);
         }
         else {
             //Ensure dependencies are installed
             const refs = assetVersion.dependencies.map((dep) => dep.name);
             if (refs.length > 0) {
-                tasks = this._install(refs);
+                tasks = await this.scheduleInstallation(refs);
             }
         }
         if (tasks && wait) {

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/BlockInstanceRunner.js

@@ -27,8 +27,9 @@ const DOCKER_ENV_VARS = [
     `KAPETA_LOCAL_CLUSTER_HOST=host.docker.internal`,
     `KAPETA_ENVIRONMENT_TYPE=docker`,
 ];
-function getProvider(uri) {
-    return definitionsManager_1.definitionsManager.getProviderDefinitions().find((provider) => {
+async function getProvider(uri) {
+    const providers = await definitionsManager_1.definitionsManager.getProviderDefinitions();
+    return providers.find((provider) => {
         const ref = `${provider.definition.metadata.name}:${provider.version}`;
         return (0, nodejs_utils_1.parseKapetaUri)(ref).id === uri.id;
     });
@@ -76,15 +77,12 @@ class BlockInstanceRunner {
         if (!blockUri.version) {
             blockUri.version = 'local';
         }
-        const assetVersion = definitionsManager_1.definitionsManager.getDefinitions().find((definitions) => {
-            const ref = `${definitions.definition.metadata.name}:${definitions.version}`;
-            return (0, nodejs_utils_1.parseKapetaUri)(ref).id === blockUri.id;
-        });
+        const assetVersion = await definitionsManager_1.definitionsManager.getDefinition(blockUri.id);
         if (!assetVersion) {
             throw new Error(`Block definition not found: ${blockUri.id}`);
         }
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.kind);
-        const providerVersion = getProvider(kindUri);
+        const providerVersion = await getProvider(kindUri);
         if (!providerVersion) {
             throw new Error(`Kind not found: ${kindUri.id}`);
         }
@@ -120,7 +118,7 @@ class BlockInstanceRunner {
             throw new Error('Missing target kind in block definition');
         }
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.spec?.target?.kind);
-        const targetVersion = getProvider(kindUri);
+        const targetVersion = await getProvider(kindUri);
         if (!targetVersion) {
             throw new Error(`Target not found: ${kindUri.id}`);
         }

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,52 @@
-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");
+const authManager_1 = require("./src/authManager");
 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 +61,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 +84,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 +103,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 +127,16 @@ export default {
         if (pingResult?.ok) {
             throw new Error(`Cluster service already running on: ${clusterHost}:${clusterPort}.`);
         }
-        await clusterService.init();
+        await clusterService_1.clusterService.init();
+        await authManager_1.authManager.listenForChanges();
         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 +150,22 @@ export default {
                 }
                 reject(err);
             });
-            const bindHost = getBindHost(host);
-            currentServer.listen(port, bindHost, () => {
+            const bindHost = (0, utils_1.getBindHost)(host);
+            currentServer.listen(port, bindHost, async () => {
                 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();
+                    await 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 +186,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;