@kapeta/local-cluster-service 0.15.1 → 0.15.3

package/dist/esm/src/instanceManager.js

@@ -3,7 +3,7 @@ import request from 'request';
 import AsyncLock from 'async-lock';
 import { BlockInstanceRunner } from './utils/BlockInstanceRunner';
 import { storageService } from './storageService';
-import { socketManager } from './socketManager';
+import { EVENT_INSTANCE_CREATED, EVENT_INSTANCE_EXITED, EVENT_STATUS_CHANGED, socketManager, } from './socketManager';
 import { serviceManager } from './serviceManager';
 import { assetManager } from './assetManager';
 import { containerManager, HEALTH_CHECK_TIMEOUT } from './containerManager';
@@ -16,10 +16,6 @@ import { definitionsManager } from './definitionsManager';
 import { Task, taskManager } from './taskManager';
 const CHECK_INTERVAL = 5000;
 const DEFAULT_HEALTH_PORT_TYPE = 'rest';
-const EVENT_STATUS_CHANGED = 'status-changed';
-const EVENT_INSTANCE_CREATED = 'instance-created';
-const EVENT_INSTANCE_EXITED = 'instance-exited';
-const EVENT_INSTANCE_LOG = 'instance-log';
 const MIN_TIME_RUNNING = 30000; //If something didnt run for more than 30 secs - it failed
 export class InstanceManager {
     _interval = undefined;
@@ -115,11 +111,11 @@ export class InstanceManager {
         if (existingInstance) {
             const ix = this._instances.indexOf(existingInstance);
             this._instances.splice(ix, 1, instance);
-            this.emitSystemEvent(instance.systemId, EVENT_STATUS_CHANGED, instance);
+            socketManager.emitSystemEvent(instance.systemId, EVENT_STATUS_CHANGED, instance);
         }
         else {
             this._instances.push(instance);
-            this.emitSystemEvent(instance.systemId, EVENT_INSTANCE_CREATED, instance);
+            socketManager.emitSystemEvent(instance.systemId, EVENT_INSTANCE_CREATED, instance);
         }
         this.save();
         return instance;
@@ -162,7 +158,7 @@ export class InstanceManager {
                 if (healthUrl) {
                     instance.health = healthUrl;
                 }
-                this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+                socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
             }
             else {
                 //If instance was not found - then we're receiving an externally started instance
@@ -178,7 +174,7 @@ export class InstanceManager {
                     address,
                 };
                 this._instances.push(instance);
-                this.emitSystemEvent(systemId, EVENT_INSTANCE_CREATED, instance);
+                socketManager.emitSystemEvent(systemId, EVENT_INSTANCE_CREATED, instance);
             }
             this.save();
             return instance;
@@ -203,7 +199,7 @@ export class InstanceManager {
                 instance.status = InstanceStatus.STOPPED;
                 instance.pid = null;
                 instance.health = null;
-                this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+                socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
                 this.save();
             }
         });
@@ -261,7 +257,7 @@ export class InstanceManager {
                 instance.desiredStatus = DesiredInstanceStatus.STOP;
             }
             instance.status = InstanceStatus.STOPPING;
-            this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+            socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
             console.log('Stopping instance: %s::%s [desired: %s]', systemId, instanceId, instance.desiredStatus);
             this.save();
             try {
@@ -272,7 +268,7 @@ export class InstanceManager {
                         try {
                             await container.stop();
                             instance.status = InstanceStatus.STOPPED;
-                            this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+                            socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
                             this.save();
                         }
                         catch (e) {
@@ -291,7 +287,7 @@ export class InstanceManager {
                 }
                 process.kill(instance.pid, 'SIGTERM');
                 instance.status = InstanceStatus.STOPPED;
-                this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+                socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
                 this.save();
             }
             catch (e) {
@@ -416,8 +412,8 @@ export class InstanceManager {
                         status: InstanceStatus.FAILED,
                         errorMessage: e.message ?? 'Failed to start - Check logs for details.',
                     });
-                    this.emitInstanceEvent(systemId, instanceId, EVENT_INSTANCE_LOG, logs[0]);
-                    this.emitInstanceEvent(systemId, blockInstance.id, EVENT_INSTANCE_EXITED, {
+                    socketManager.emitInstanceLog(systemId, instanceId, logs[0]);
+                    socketManager.emitInstanceEvent(systemId, blockInstance.id, EVENT_INSTANCE_EXITED, {
                         error: `Failed to start instance: ${e.message}`,
                         status: EVENT_INSTANCE_EXITED,
                         instanceId: blockInstance.id,
@@ -506,7 +502,7 @@ export class InstanceManager {
                         const oldStatus = instance.status;
                         instance.status = newStatus;
                         console.log('Instance status changed: %s %s: %s -> %s', instance.systemId, instance.instanceId, oldStatus, instance.status);
-                        this.emitSystemEvent(instance.systemId, EVENT_STATUS_CHANGED, instance);
+                        socketManager.emitSystemEvent(instance.systemId, EVENT_STATUS_CHANGED, instance);
                         changed = true;
                     }
                 }
@@ -638,24 +634,6 @@ export class InstanceManager {
             });
         });
     }
-    emitSystemEvent(systemId, type, payload) {
-        systemId = normalizeKapetaUri(systemId);
-        try {
-            socketManager.emit(`${systemId}/instances`, type, payload);
-        }
-        catch (e) {
-            console.warn('Failed to emit instance event: %s', e.message);
-        }
-    }
-    emitInstanceEvent(systemId, instanceId, type, payload) {
-        systemId = normalizeKapetaUri(systemId);
-        try {
-            socketManager.emit(`${systemId}/instances/${instanceId}`, type, payload);
-        }
-        catch (e) {
-            console.warn('Failed to emit instance event: %s', e.message);
-        }
-    }
 }
 export const instanceManager = new InstanceManager();
 process.on('exit', async () => {

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

@@ -1,8 +1,9 @@
 /// <reference types="node" />
-import { SocketManager } from './socketManager';
-declare class ProgressListener {
-    private socketManager;
-    constructor(socketManager: SocketManager);
+export declare class ProgressListener {
+    private readonly systemId;
+    private readonly instanceId;
+    constructor(systemId?: string, instanceId?: string);
+    private emitLog;
     run(command: string, directory?: string): Promise<{
         exit: number;
         signal: NodeJS.Signals | null;
@@ -17,5 +18,3 @@ declare class ProgressListener {
     info(msg: string, ...args: any[]): void;
     debug(msg: string, ...args: any[]): void;
 }
-export declare const progressListener: ProgressListener;
-export {};

package/dist/esm/src/progressListener.js

@@ -1,16 +1,31 @@
 import { spawn } from '@kapeta/nodejs-process';
 import { socketManager } from './socketManager';
-class ProgressListener {
-    socketManager;
-    constructor(socketManager) {
-        this.socketManager = socketManager;
+import { format } from 'node:util';
+export class ProgressListener {
+    systemId;
+    instanceId;
+    constructor(systemId, instanceId) {
+        this.systemId = systemId;
+        this.instanceId = instanceId;
+    }
+    emitLog(payload) {
+        const logEntry = {
+            ...payload,
+            source: 'stdout',
+            time: Date.now(),
+        };
+        if (this.systemId && this.instanceId) {
+            socketManager.emitInstanceLog(this.systemId, this.instanceId, logEntry);
+            return;
+        }
+        if (this.systemId) {
+            socketManager.emitSystemLog(this.systemId, logEntry);
+            return;
+        }
+        socketManager.emitGlobalLog(logEntry);
     }
     run(command, directory) {
-        this.socketManager.emit(`install`, 'install:log', {
-            type: 'info',
-            message: `Running command "${command}"`,
-        });
-        const firstCommand = command.split(' ')[0];
+        this.info(`Running command "${command}"`);
         return new Promise(async (resolve, reject) => {
             try {
                 const chunks = [];
@@ -20,7 +35,10 @@ class ProgressListener {
                     shell: true,
                 });
                 child.onData((data) => {
-                    this.socketManager.emit(`install`, 'install:log', { type: 'info', message: data.line });
+                    this.emitLog({
+                        level: data.type === 'stdout' ? 'INFO' : 'WARN',
+                        message: data.line,
+                    });
                 });
                 if (child.process.stdout) {
                     child.process.stdout.on('data', (data) => {
@@ -29,25 +47,16 @@ class ProgressListener {
                 }
                 child.process.on('exit', (exit, signal) => {
                     if (exit !== 0) {
-                        this.socketManager.emit(`install`, 'install:log', {
-                            type: 'info',
-                            message: `"${command}" failed: "${exit}"`,
-                        });
+                        this.warn(`Command "${command}" failed: ${exit}`);
                         reject(new Error(`Command "${command}" exited with code ${exit}`));
                     }
                     else {
-                        this.socketManager.emit(`install`, 'install:log', {
-                            type: 'info',
-                            message: `Command OK: "${command}"`,
-                        });
+                        this.info(`Command OK: "${command}"`);
                         resolve({ exit, signal, output: Buffer.concat(chunks).toString() });
                     }
                 });
                 child.process.on('error', (err) => {
-                    this.socketManager.emit(`install`, 'install:log', {
-                        type: 'info',
-                        message: `"${command}" failed: "${err.message}"`,
-                    });
+                    this.warn(`"${command}" failed: "${err.message}"`);
                     reject(err);
                 });
                 await child.wait();
@@ -58,41 +67,49 @@ class ProgressListener {
         });
     }
     async progress(label, callback) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: started` });
+        this.info(`${label}: started`);
         try {
             const result = await callback();
-            this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: done` });
+            this.info(`${label}: done`);
             return result;
         }
         catch (e) {
-            this.socketManager.emit(`install`, 'install:log', {
-                type: 'info',
-                message: `${label}: failed. ${e.message}`,
-            });
+            this.warn(`${label}: failed. ${e.message}`);
             throw e;
         }
     }
     async check(message, ok) {
         const wasOk = await ok;
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${message}: ${wasOk}` });
+        this.info(`${message}: ${wasOk}`);
     }
     start(label) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: label });
+        this.info(label);
     }
     showValue(label, value) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: `${label}: ${value}` });
+        this.info(`${label}: ${value}`);
     }
     error(msg, ...args) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'error', message: msg });
+        this.emitLog({
+            message: format(msg, args),
+            level: 'ERROR',
+        });
     }
     warn(msg, ...args) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'warn', message: msg });
+        this.emitLog({
+            message: format(msg, args),
+            level: 'WARN',
+        });
     }
     info(msg, ...args) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'info', message: msg });
+        this.emitLog({
+            message: format(msg, args),
+            level: 'INFO',
+        });
     }
     debug(msg, ...args) {
-        this.socketManager.emit(`install`, 'install:log', { type: 'debug', message: msg });
+        this.emitLog({
+            message: format(msg, args),
+            level: 'DEBUG',
+        });
     }
 }
-export const progressListener = new ProgressListener(socketManager);

package/dist/esm/src/repositoryManager.js

@@ -6,12 +6,14 @@ import FSExtra from 'fs-extra';
 import ClusterConfiguration from '@kapeta/local-cluster-config';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { socketManager } from './socketManager';
-import { progressListener } from './progressListener';
 import { Actions, Config, RegistryService } from '@kapeta/nodejs-registry-utils';
 import { definitionsManager } from './definitionsManager';
 import { taskManager } from './taskManager';
 import { normalizeKapetaUri } from './utils/utils';
 import { assetManager } from './assetManager';
+import { ProgressListener } from './progressListener';
+const EVENT_DEFAULT_PROVIDERS_START = 'default-providers-start';
+const EVENT_DEFAULT_PROVIDERS_END = 'default-providers-end';
 const DEFAULT_PROVIDERS = [
     'kapeta/block-type-service',
     'kapeta/block-type-frontend',
@@ -116,7 +118,11 @@ class RepositoryManager {
         this.watcher = undefined;
     }
     ensureDefaultProviders() {
-        this._install(DEFAULT_PROVIDERS);
+        socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: DEFAULT_PROVIDERS });
+        const tasks = this._install(DEFAULT_PROVIDERS);
+        Promise.allSettled(tasks.map((t) => t.wait())).then(() => {
+            socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_END, {});
+        });
     }
     _install(refs) {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
@@ -136,7 +142,7 @@ class RepositoryManager {
                     process.chdir(os.tmpdir());
                     //Disable change events while installing
                     this.setChangeEventsEnabled(false);
-                    await Actions.install(progressListener, [ref], {});
+                    await Actions.install(new ProgressListener(), [ref], {});
                 }
                 catch (e) {
                     console.error(`Failed to install asset: ${ref}`, e);

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

@@ -1,16 +1,28 @@
-import { Socket, Server } from 'socket.io';
+import { Server } from 'socket.io';
+import { LogEntry } from './types';
+export declare const EVENT_STATUS_CHANGED = "status-changed";
+export declare const EVENT_INSTANCE_CREATED = "instance-created";
+export declare const EVENT_INSTANCE_EXITED = "instance-exited";
+export declare const EVENT_INSTANCE_LOG = "instance-log";
+export declare const EVENT_SYSTEM_LOG = "system-log";
+export declare const EVENT_LOG = "log";
 export declare class SocketManager {
     private _io;
-    private _sockets;
+    private readonly _sockets;
     constructor();
     setIo(io: Server): void;
     isAlive(): boolean;
     private get io();
     emit(context: string, type: string, payload: any): void;
     emitGlobal(type: string, payload: any): void;
-    _bindIO(): void;
-    _handleSocketCreated(socket: Socket): void;
-    _bindSocket(socket: Socket): void;
-    _handleSocketDestroyed(socket: Socket): void;
+    emitSystemEvent(systemId: string, type: string, payload: any): void;
+    emitInstanceLog(systemId: string, instanceId: string, payload: LogEntry): void;
+    emitSystemLog(systemId: string, payload: LogEntry): void;
+    emitGlobalLog(payload: LogEntry): void;
+    emitInstanceEvent(systemId: string, instanceId: string, type: string, payload: any): void;
+    private _bindIO;
+    private _handleSocketCreated;
+    private _bindSocket;
+    private _handleSocketDestroyed;
 }
 export declare const socketManager: SocketManager;

package/dist/esm/src/socketManager.js

@@ -1,4 +1,11 @@
 import _ from 'lodash';
+import { normalizeKapetaUri } from './utils/utils';
+export const EVENT_STATUS_CHANGED = 'status-changed';
+export const EVENT_INSTANCE_CREATED = 'instance-created';
+export const EVENT_INSTANCE_EXITED = 'instance-exited';
+export const EVENT_INSTANCE_LOG = 'instance-log';
+export const EVENT_SYSTEM_LOG = 'system-log';
+export const EVENT_LOG = 'log';
 export class SocketManager {
     _io;
     _sockets;
@@ -26,6 +33,33 @@ export class SocketManager {
     emitGlobal(type, payload) {
         this.io.emit(type, payload);
     }
+    emitSystemEvent(systemId, type, payload) {
+        systemId = normalizeKapetaUri(systemId);
+        try {
+            socketManager.emit(`${systemId}/instances`, type, payload);
+        }
+        catch (e) {
+            console.warn('Failed to emit instance event: %s', e.message);
+        }
+    }
+    emitInstanceLog(systemId, instanceId, payload) {
+        this.emitInstanceEvent(systemId, instanceId, EVENT_INSTANCE_LOG, payload);
+    }
+    emitSystemLog(systemId, payload) {
+        this.emitSystemEvent(systemId, EVENT_SYSTEM_LOG, payload);
+    }
+    emitGlobalLog(payload) {
+        this.emitGlobal(EVENT_LOG, payload);
+    }
+    emitInstanceEvent(systemId, instanceId, type, payload) {
+        systemId = normalizeKapetaUri(systemId);
+        try {
+            socketManager.emit(`${systemId}/instances/${instanceId}`, type, payload);
+        }
+        catch (e) {
+            console.warn('Failed to emit instance event: %s', e.message);
+        }
+    }
     _bindIO() {
         this.io.on('connection', (socket) => this._handleSocketCreated(socket));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.15.1",
+    "version": "0.15.3",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/assetManager.ts

@@ -3,9 +3,9 @@ import FS from 'node:fs';
 import FSExtra from 'fs-extra';
 import YAML from 'yaml';
 import NodeCache from 'node-cache';
-import ClusterConfiguration, { Definition, DefinitionInfo } from '@kapeta/local-cluster-config';
+import { Definition, DefinitionInfo } from '@kapeta/local-cluster-config';
 import { codeGeneratorManager } from './codeGeneratorManager';
-import { progressListener } from './progressListener';
+import { ProgressListener } from './progressListener';
 import { parseKapetaUri } from '@kapeta/nodejs-utils';
 import { repositoryManager } from './repositoryManager';
 import { BlockDefinition } from '@kapeta/schemas';
@@ -209,7 +209,7 @@ class AssetManager {
 
         const assetInfos = YAML.parseAllDocuments(FS.readFileSync(filePath).toString()).map((doc) => doc.toJSON());
 
-        await Actions.link(progressListener, Path.dirname(filePath));
+        await Actions.link(new ProgressListener(), Path.dirname(filePath));
 
         const version = 'local';
         const refs = assetInfos.map((assetInfo) => `kapeta://${assetInfo.metadata.name}:${version}`);
@@ -223,7 +223,7 @@ class AssetManager {
             throw new Error('Asset does not exists: ' + ref);
         }
         this.cache.flushAll();
-        await Actions.uninstall(progressListener, [asset.ref]);
+        await Actions.uninstall(new ProgressListener(), [asset.ref]);
     }
 
     async installAsset(ref: string) {

package/src/containerManager.ts

@@ -11,14 +11,9 @@ import uuid from 'node-uuid';
 import md5 from 'md5';
 import { getBlockInstanceContainerName } from './utils/utils';
 import { InstanceInfo, LogEntry, LogSource } from './types';
-import { socketManager } from './socketManager';
-import { handlers as ArtifactHandlers } from '@kapeta/nodejs-registry-utils';
-import { progressListener } from './progressListener';
 import { KapetaAPI } from '@kapeta/nodejs-api-client';
 import { taskManager, Task } from './taskManager';
 
-const EVENT_IMAGE_PULL = 'docker-image-pull';
-
 type StringMap = { [key: string]: string };
 
 export type PortMap = {

package/src/identities/routes.ts

@@ -5,12 +5,13 @@ import { corsHandler } from '../middleware/cors';
 import { Request, Response } from 'express';
 
 const router = Router();
-const api = new KapetaAPI();
+
 
 router.use('/', corsHandler);
 
 router.get('/current', async (req: Request, res: Response) => {
     try {
+        const api = new KapetaAPI();
         if (api.hasToken()) {
             res.send(await api.getCurrentIdentity());
         } else {
@@ -23,6 +24,7 @@ router.get('/current', async (req: Request, res: Response) => {
 
 router.get('/:identityId/memberships', async (req: Request, res: Response) => {
     try {
+        const api = new KapetaAPI();
         if (api.hasToken()) {
             res.send(await api.getMemberships(req.params.identityId));
         } else {

package/src/instanceManager.ts

@@ -3,7 +3,13 @@ import request from 'request';
 import AsyncLock from 'async-lock';
 import { BlockInstanceRunner } from './utils/BlockInstanceRunner';
 import { storageService } from './storageService';
-import { socketManager } from './socketManager';
+import {
+    EVENT_INSTANCE_CREATED,
+    EVENT_INSTANCE_EXITED,
+    EVENT_INSTANCE_LOG,
+    EVENT_STATUS_CHANGED,
+    socketManager,
+} from './socketManager';
 import { serviceManager } from './serviceManager';
 import { assetManager } from './assetManager';
 import { containerManager, HEALTH_CHECK_TIMEOUT } from './containerManager';
@@ -19,10 +25,6 @@ import { Task, taskManager } from './taskManager';
 const CHECK_INTERVAL = 5000;
 const DEFAULT_HEALTH_PORT_TYPE = 'rest';
 
-const EVENT_STATUS_CHANGED = 'status-changed';
-const EVENT_INSTANCE_CREATED = 'instance-created';
-const EVENT_INSTANCE_EXITED = 'instance-exited';
-const EVENT_INSTANCE_LOG = 'instance-log';
 const MIN_TIME_RUNNING = 30000; //If something didnt run for more than 30 secs - it failed
 
 export class InstanceManager {
@@ -153,10 +155,10 @@ export class InstanceManager {
         if (existingInstance) {
             const ix = this._instances.indexOf(existingInstance);
             this._instances.splice(ix, 1, instance);
-            this.emitSystemEvent(instance.systemId, EVENT_STATUS_CHANGED, instance);
+            socketManager.emitSystemEvent(instance.systemId, EVENT_STATUS_CHANGED, instance);
         } else {
             this._instances.push(instance);
-            this.emitSystemEvent(instance.systemId, EVENT_INSTANCE_CREATED, instance);
+            socketManager.emitSystemEvent(instance.systemId, EVENT_INSTANCE_CREATED, instance);
         }
 
         this.save();
@@ -222,7 +224,7 @@ export class InstanceManager {
                     instance.health = healthUrl;
                 }
 
-                this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+                socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
             } else {
                 //If instance was not found - then we're receiving an externally started instance
                 instance = {
@@ -239,7 +241,7 @@ export class InstanceManager {
 
                 this._instances.push(instance);
 
-                this.emitSystemEvent(systemId, EVENT_INSTANCE_CREATED, instance);
+                socketManager.emitSystemEvent(systemId, EVENT_INSTANCE_CREATED, instance);
             }
 
             this.save();
@@ -268,7 +270,7 @@ export class InstanceManager {
                 instance.status = InstanceStatus.STOPPED;
                 instance.pid = null;
                 instance.health = null;
-                this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+                socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
                 this.save();
             }
         });
@@ -343,7 +345,7 @@ export class InstanceManager {
 
             instance.status = InstanceStatus.STOPPING;
 
-            this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+            socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
             console.log('Stopping instance: %s::%s [desired: %s]', systemId, instanceId, instance.desiredStatus);
             this.save();
 
@@ -355,7 +357,7 @@ export class InstanceManager {
                         try {
                             await container.stop();
                             instance.status = InstanceStatus.STOPPED;
-                            this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+                            socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
                             this.save();
                         } catch (e) {
                             console.error('Failed to stop container', e);
@@ -374,7 +376,7 @@ export class InstanceManager {
 
                 process.kill(instance.pid as number, 'SIGTERM');
                 instance.status = InstanceStatus.STOPPED;
-                this.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
+                socketManager.emitSystemEvent(systemId, EVENT_STATUS_CHANGED, instance);
                 this.save();
             } catch (e) {
                 console.error('Failed to stop process', e);
@@ -528,9 +530,9 @@ export class InstanceManager {
                             errorMessage: e.message ?? 'Failed to start - Check logs for details.',
                         });
 
-                        this.emitInstanceEvent(systemId, instanceId, EVENT_INSTANCE_LOG, logs[0]);
+                        socketManager.emitInstanceLog(systemId, instanceId, logs[0]);
 
-                        this.emitInstanceEvent(systemId, blockInstance.id, EVENT_INSTANCE_EXITED, {
+                        socketManager.emitInstanceEvent(systemId, blockInstance.id, EVENT_INSTANCE_EXITED, {
                             error: `Failed to start instance: ${e.message}`,
                             status: EVENT_INSTANCE_EXITED,
                             instanceId: blockInstance.id,
@@ -645,7 +647,7 @@ export class InstanceManager {
                             oldStatus,
                             instance.status
                         );
-                        this.emitSystemEvent(instance.systemId, EVENT_STATUS_CHANGED, instance);
+                        socketManager.emitSystemEvent(instance.systemId, EVENT_STATUS_CHANGED, instance);
                         changed = true;
                     }
                 }
@@ -802,24 +804,6 @@ export class InstanceManager {
             });
         });
     }
-
-    private emitSystemEvent(systemId: string, type: string, payload: any) {
-        systemId = normalizeKapetaUri(systemId);
-        try {
-            socketManager.emit(`${systemId}/instances`, type, payload);
-        } catch (e: any) {
-            console.warn('Failed to emit instance event: %s', e.message);
-        }
-    }
-
-    private emitInstanceEvent(systemId: string, instanceId: string, type: string, payload: any) {
-        systemId = normalizeKapetaUri(systemId);
-        try {
-            socketManager.emit(`${systemId}/instances/${instanceId}`, type, payload);
-        } catch (e: any) {
-            console.warn('Failed to emit instance event: %s', e.message);
-        }
-    }
 }
 
 export const instanceManager = new InstanceManager();