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

package/dist/esm/src/proxy/types/rest.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyRestRequest = exports.getRestMethodId = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const request_1 = __importDefault(require("request"));
+const path_1 = __importDefault(require("path"));
+const pathTemplateParser_1 = require("../../utils/pathTemplateParser");
+const networkManager_1 = require("../../networkManager");
+const socketManager_1 = require("../../socketManager");
+const qs_1 = require("qs");
+function getRestMethodId(restResource, httpMethod, httpPath) {
+    return lodash_1.default.findKey(restResource.spec.methods, (method) => {
+        let methodType = method.method ? method.method.toUpperCase() : 'GET';
+        if (methodType.toUpperCase() !== httpMethod.toUpperCase()) {
+            return false;
+        }
+        let path = method.path;
+        if (restResource.spec.basePath) {
+            path = path_1.default.join(restResource.spec.basePath, path);
+        }
+        const pathTemplate = (0, pathTemplateParser_1.pathTemplateParser)(path);
+        return pathTemplate.matches(httpPath);
+    });
+}
+exports.getRestMethodId = getRestMethodId;
+/**
+ *
+ * @param req {Request}
+ * @param opts {ProxyRequestInfo}
+ * @return {{consumerMethod: *, providerMethod: *}}
+ */
+function resolveMethods(req, opts) {
+    const consumerMethodId = getRestMethodId(opts.consumerResource, req.method, opts.consumerPath);
+    if (!consumerMethodId) {
+        throw new Error(`Consumer method not found for path "${req.method} ${opts.consumerPath}" in resource "${req.params.consumerInstanceId}::${req.params.consumerResourceName}`);
+    }
+    const consumerMethod = lodash_1.default.cloneDeep(opts.consumerResource.spec.methods[consumerMethodId]);
+    if (!consumerMethod) {
+        throw new Error(`Consumer method not found for path "${req.method} ${opts.consumerPath}" in resource "${req.params.consumerInstanceId}::${req.params.consumerResourceName}`);
+    }
+    consumerMethod.id = consumerMethodId;
+    const providerMethodId = lodash_1.default.findKey(opts.connection.mapping, (mapping) => {
+        return mapping.targetId === consumerMethodId;
+    });
+    if (!providerMethodId) {
+        throw new Error(`Connection contained no mapping for consumer method "${consumerMethodId}`);
+    }
+    const providerMethod = lodash_1.default.cloneDeep(opts.providerResource.spec.methods[providerMethodId]);
+    if (!providerMethod) {
+        throw new Error(`Provider method not found "${providerMethodId}" in resource "${opts.connection.provider.blockId}::${opts.connection.provider.resourceName}`);
+    }
+    providerMethod.id = providerMethodId;
+    return {
+        consumerMethod,
+        providerMethod,
+    };
+}
+function proxyRestRequest(req, res, opts) {
+    let { consumerMethod, providerMethod } = resolveMethods(req, opts);
+    const consumerPathTemplate = (0, pathTemplateParser_1.pathTemplateParser)(consumerMethod.path);
+    const providerPathTemplate = (0, pathTemplateParser_1.pathTemplateParser)(providerMethod.path);
+    const pathVariables = consumerPathTemplate.parse(opts.consumerPath);
+    if (!pathVariables) {
+        res.status(400).send({
+            error: `Path did not match any patterns: "${opts.consumerPath}"`,
+        });
+        return;
+    }
+    let providerPath = providerPathTemplate.create(pathVariables);
+    if (!providerPath.startsWith('/')) {
+        providerPath = '/' + providerPath;
+    }
+    if (!lodash_1.default.isEmpty(req.query)) {
+        providerPath += '?' + (0, qs_1.stringify)(req.query, { arrayFormat: 'repeat' });
+    }
+    const requestHeaders = lodash_1.default.clone(req.headers);
+    delete requestHeaders['content-length'];
+    delete requestHeaders['content-encoding'];
+    delete requestHeaders['connection'];
+    delete requestHeaders['host'];
+    delete requestHeaders['origin'];
+    console.log('Proxy request to provider: %s => %s [rest]', opts.consumerPath, opts.address + providerPath);
+    const reqOpts = {
+        method: providerMethod.method || 'GET',
+        url: opts.address + providerPath,
+        body: req.stringBody,
+        headers: requestHeaders,
+    };
+    const traffic = networkManager_1.networkManager.addRequest(req.params.systemId, opts.connection, reqOpts, consumerMethod.id, providerMethod.id);
+    socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
+    (0, request_1.default)(reqOpts, function (err, response, responseBody) {
+        if (err) {
+            traffic.asError(err);
+            socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+            res.status(500).send({ error: '' + err });
+            return;
+        }
+        const responseHeaders = lodash_1.default.clone(response.headers);
+        delete responseHeaders['content-length'];
+        delete responseHeaders['content-encoding'];
+        delete responseHeaders['connection'];
+        res.set(responseHeaders);
+        res.status(response.statusCode);
+        traffic.withResponse({
+            code: response.statusCode,
+            headers: response.headers,
+            body: responseBody,
+        });
+        socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+        if (responseBody) {
+            res.write(responseBody);
+        }
+        res.end();
+    });
+}
+exports.proxyRestRequest = proxyRestRequest;

package/dist/esm/src/proxy/types/web.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { Response } from 'express';
+import { ProxyRequestInfo } from '../../types';
+import { StringBodyRequest } from '../../middleware/stringBody';
+export declare function proxyHttpRequest(req: StringBodyRequest, res: Response, opts: ProxyRequestInfo): void;

package/dist/esm/src/proxy/types/web.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyHttpRequest = void 0;
+const request_1 = __importDefault(require("request"));
+const lodash_1 = __importDefault(require("lodash"));
+const networkManager_1 = require("../../networkManager");
+const socketManager_1 = require("../../socketManager");
+const qs_1 = require("qs");
+function proxyHttpRequest(req, res, opts) {
+    const requestHeaders = lodash_1.default.clone(req.headers);
+    delete requestHeaders['content-length'];
+    delete requestHeaders['content-encoding'];
+    delete requestHeaders['connection'];
+    delete requestHeaders['host'];
+    delete requestHeaders['origin'];
+    const sourceBasePath = opts.consumerResource.spec.path;
+    const targetBasePath = opts.providerResource.spec.path;
+    let path = opts.consumerPath;
+    if (opts.consumerPath.startsWith(sourceBasePath)) {
+        path = path.replace(sourceBasePath, targetBasePath);
+    }
+    if (!lodash_1.default.isEmpty(req.query)) {
+        path += '?' + (0, qs_1.stringify)(req.query, { arrayFormat: 'repeat' });
+    }
+    console.log('Proxy request to provider: %s => %s%s [http]', opts.consumerPath, opts.address, path);
+    const reqOpts = {
+        method: req.method,
+        url: opts.address + path,
+        headers: requestHeaders,
+        body: req.stringBody,
+    };
+    const traffic = networkManager_1.networkManager.addRequest(req.params.systemId, opts.connection, reqOpts);
+    socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
+    const proxyReq = (0, request_1.default)(reqOpts);
+    proxyReq.on('error', function (err) {
+        traffic.asError(err);
+        socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+        if (!res.headersSent) {
+            res.status(500).send({ error: '' + err });
+        }
+    });
+    proxyReq.on('response', function (response) {
+        //TODO: Include the response body in the traffic object when it is not a stream
+        traffic.withResponse({
+            code: response.statusCode,
+            headers: response.headers,
+            body: null,
+        });
+        socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
+    });
+    //We need to pipe the proxy response to the client response to handle sockets and event streams
+    proxyReq.pipe(res);
+}
+exports.proxyHttpRequest = proxyHttpRequest;

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

@@ -0,0 +1,35 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="node" />
+import { Task } from './taskManager';
+import { SourceOfChange } from './types';
+import { EventEmitter } from 'node:events';
+declare class RepositoryManager extends EventEmitter {
+    private _registryService;
+    private watcher;
+    constructor();
+    listenForChanges(): void;
+    stopListening(): Promise<void>;
+    /**
+     * Setting the source of change helps us know
+     * how to react to changes in the UI.
+     */
+    setSourceOfChangeFor(file: string, source: SourceOfChange): Promise<void>;
+    clearSourceOfChangeFor(file: string): Promise<void>;
+    ensureDefaultProviders(): Promise<void>;
+    /**
+     * Will go through all available assets and get a list of
+     * providers that are not referenced anywhere.
+     *
+     * It will also make sure to not include the latest version of an asset.
+     *
+     */
+    getUnusedProviders(): Promise<string[]>;
+    getUpdatableAssets(allNames: string[]): Promise<string[]>;
+    private scheduleInstallation;
+    ensureAsset(handle: string, name: string, version: string, wait?: boolean): Promise<undefined | Task[]>;
+}
+export declare const repositoryManager: RepositoryManager;
+export {};

package/dist/esm/src/repositoryManager.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repositoryManager = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const socketManager_1 = require("./socketManager");
+const schemas_1 = require("@kapeta/schemas");
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const definitionsManager_1 = require("./definitionsManager");
+const taskManager_1 = require("./taskManager");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const progressListener_1 = require("./progressListener");
+const RepositoryWatcher_1 = require("./RepositoryWatcher");
+const cacheManager_1 = require("./cacheManager");
+const node_events_1 = require("node:events");
+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',
+    'kapeta/block-type-gateway-http',
+    'kapeta/resource-type-rest-api',
+    'kapeta/resource-type-rest-client',
+    'kapeta/resource-type-web-page',
+    'kapeta/resource-type-web-fragment',
+    'kapeta/resource-type-mongodb',
+    'kapeta/resource-type-postgresql',
+    'kapeta/resource-type-smtp-client',
+    'kapeta/language-target-react-ts',
+    'kapeta/language-target-nodejs',
+];
+class RepositoryManager extends node_events_1.EventEmitter {
+    _registryService;
+    watcher;
+    constructor() {
+        super();
+        this._registryService = new nodejs_registry_utils_1.RegistryService(nodejs_registry_utils_1.Config.data.registry.url);
+        this.watcher = new RepositoryWatcher_1.RepositoryWatcher();
+        this.listenForChanges();
+        this.watcher.on('change', (file, source) => {
+            this.emit('change', file, source);
+        });
+    }
+    listenForChanges() {
+        this.watcher.watch();
+    }
+    async stopListening() {
+        return this.watcher.unwatch();
+    }
+    /**
+     * Setting the source of change helps us know
+     * how to react to changes in the UI.
+     */
+    setSourceOfChangeFor(file, source) {
+        return this.watcher.setSourceOfChangeFor(file, source);
+    }
+    clearSourceOfChangeFor(file) {
+        return this.watcher.clearSourceOfChangeFor(file);
+    }
+    async ensureDefaultProviders() {
+        socketManager_1.socketManager.emitGlobal(EVENT_DEFAULT_PROVIDERS_START, { providers: 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, {});
+        });
+    }
+    /**
+     * Will go through all available assets and get a list of
+     * providers that are not referenced anywhere.
+     *
+     * It will also make sure to not include the latest version of an asset.
+     *
+     */
+    async getUnusedProviders() {
+        const allDefinitions = await definitionsManager_1.definitionsManager.getDefinitions();
+        const blocks = [];
+        const plans = [];
+        const providerMap = new Map();
+        const providerVersions = {};
+        const unusedProviders = new Set();
+        allDefinitions.forEach((d) => {
+            if (d.definition.kind === 'core/plan') {
+                plans.push(d);
+                return;
+            }
+            if (d.definition.kind.startsWith('core/')) {
+                const ref = (0, nodejs_utils_1.normalizeKapetaUri)(`${d.definition.metadata.name}:${d.version}`);
+                providerMap.set(ref, d);
+                if (!providerVersions[d.definition.metadata.name]) {
+                    providerVersions[d.definition.metadata.name] = new Set();
+                }
+                providerVersions[d.definition.metadata.name].add(d.version);
+                unusedProviders.add(ref);
+                return;
+            }
+            blocks.push(d);
+        });
+        const latestVersions = {};
+        Object.entries(providerVersions).forEach(([name, versions]) => {
+            const versionArray = Array.from(versions);
+            versionArray.sort((a, b) => {
+                return (0, nodejs_utils_1.parseVersion)(a).compareTo((0, nodejs_utils_1.parseVersion)(b)) * -1;
+            });
+            latestVersions[name] = versionArray[0];
+        });
+        function markDependencyAsUsed(dep) {
+            const uri = (0, nodejs_utils_1.parseKapetaUri)(dep.name);
+            const ref = uri.toNormalizedString();
+            if (unusedProviders.has(ref)) {
+                unusedProviders.delete(ref);
+            }
+        }
+        plans.forEach((plan) => {
+            const dependencies = (0, schemas_1.resolveDependencies)(plan.definition);
+            dependencies.forEach(markDependencyAsUsed);
+        });
+        blocks.forEach((block) => {
+            const blockTypeKind = (0, nodejs_utils_1.normalizeKapetaUri)(block.definition.kind);
+            unusedProviders.delete(blockTypeKind);
+            const blockTypeProvider = providerMap.get(blockTypeKind);
+            if (!blockTypeProvider) {
+                console.warn('No provider found for block type', block.definition.kind);
+                return;
+            }
+            const dependencies = (0, schemas_1.resolveDependencies)(block.definition, blockTypeProvider.definition);
+            dependencies.forEach(markDependencyAsUsed);
+        });
+        return Array.from(unusedProviders).filter((ref) => {
+            const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+            if (uri.version == 'local') {
+                // Don't delete local assets
+                return false;
+            }
+            // Don't delete the latest version of an asset
+            return latestVersions[uri.fullName] !== uri.version;
+        });
+    }
+    async getUpdatableAssets(allNames) {
+        const names = Array.from(new Set(allNames));
+        const currentVersions = await Promise.all(names.map((name) => definitionsManager_1.definitionsManager.getLatestDefinition(name).catch(() => undefined)));
+        const latestVersions = await Promise.all(names.map((name) => this._registryService.getLatestVersion(name).catch(() => undefined)));
+        return names
+            .map((name, index) => {
+            const currentVersion = currentVersions[index];
+            const latestVersion = latestVersions[index];
+            if (!currentVersion || !latestVersion) {
+                // Shouldn't happen unless the registry is down or an asset was deleted
+                return undefined;
+            }
+            const ref = (0, nodejs_utils_1.normalizeKapetaUri)(`${name}:${latestVersion.version}`);
+            if (currentVersion.version === latestVersion.version) {
+                return undefined;
+            }
+            return ref;
+        })
+            .filter((ref) => !!ref);
+    }
+    async scheduleInstallation(refs) {
+        //We make sure to only install one asset at a time - otherwise unexpected things might happen
+        const createInstaller = (ref) => {
+            return async (task) => {
+                if (await definitionsManager_1.definitionsManager.exists(ref)) {
+                    return;
+                }
+                const progressListener = new progressListener_1.TaskProgressListener(task);
+                //console.log(`Installing asset: ${ref}`);
+                //Auto-install missing asset
+                try {
+                    //We change to a temp dir to avoid issues with the current working directory
+                    process.chdir(node_os_1.default.tmpdir());
+                    await nodejs_registry_utils_1.Actions.install(progressListener, [ref], {});
+                }
+                catch (e) {
+                    console.error(`Failed to install asset: ${ref}`, e);
+                    throw e;
+                }
+                cacheManager_1.cacheManager.flush();
+                if (await definitionsManager_1.definitionsManager.exists(ref)) {
+                    return;
+                }
+                throw new Error(`Failed to find asset after installation: ${ref}. Please try again`);
+            };
+        };
+        const tasks = [];
+        while (refs.length > 0) {
+            let ref = refs.shift();
+            if (!ref) {
+                continue;
+            }
+            ref = (0, nodejs_utils_1.normalizeKapetaUri)(ref);
+            if (await definitionsManager_1.definitionsManager.exists(ref)) {
+                continue;
+            }
+            const task = taskManager_1.taskManager.add(`asset:install:${ref}`, createInstaller(ref), {
+                name: `Installing ${ref}`,
+                group: 'asset:install:', //Group prevents multiple tasks from running at the same time
+            });
+            tasks.push(task);
+        }
+        return tasks;
+    }
+    async ensureAsset(handle, name, version, wait = true) {
+        const fullName = `${handle}/${name}`;
+        const ref = `${fullName}:${version}`;
+        if (version === 'local') {
+            //TODO: Get dependencies for local asset
+            return;
+        }
+        const installedAsset = await definitionsManager_1.definitionsManager.getDefinition(`${fullName}:${version}`);
+        let assetVersion;
+        try {
+            assetVersion = await this._registryService.getVersion(fullName, version);
+            if (!assetVersion) {
+                return;
+            }
+        }
+        catch (e) {
+            console.warn(`Unable to resolve asset: ${ref}`, e);
+            if (installedAsset) {
+                return;
+            }
+            throw e;
+        }
+        let tasks = undefined;
+        if (!installedAsset) {
+            tasks = await this.scheduleInstallation([ref]);
+        }
+        else {
+            //Ensure dependencies are installed
+            const refs = assetVersion.dependencies.map((dep) => dep.name);
+            if (refs.length > 0) {
+                tasks = await this.scheduleInstallation(refs);
+            }
+        }
+        if (tasks && wait) {
+            await Promise.all(tasks.map((t) => t.wait()));
+        }
+        return tasks;
+    }
+}
+exports.repositoryManager = new RepositoryManager();

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

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { EnvironmentType } from './types';
+export declare const HTTP_PORT_TYPE = "http";
+export declare const DEFAULT_PORT_TYPE = "http";
+export declare const HTTP_PORTS: string[];
+declare class ServiceManager {
+    private _systems;
+    constructor();
+    _forLocal(port: string | number, path?: string, environmentType?: EnvironmentType): string;
+    _ensureSystem(systemId: string): any;
+    _ensureService(systemId: string, serviceId: string): any;
+    ensureServicePort(systemId: string, blockInstanceId: string, portType?: string): Promise<any>;
+    _save(): void;
+    /**
+     * Gets the consumable address of a service block resource
+     *
+     * This returns a local proxy path to allow traffic inspection and control.
+     *
+     */
+    getConsumerAddress(systemId: string, consumerInstanceId: string, consumerResourceName: string, portType: string, environmentType?: EnvironmentType): string;
+    /**
+     * Gets the direct address of a service block
+     *
+     * This returns the actual endpoint address of a service that we're talking to.
+     * For local services this address will be on localhost - for remote services it will
+     * be their remotely available address.
+     *
+     */
+    getProviderAddress(systemId: string, providerInstanceId: string, portType: string): Promise<string>;
+    getServices(): any;
+}
+export declare const serviceManager: ServiceManager;
+export {};

package/dist/esm/src/serviceManager.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceManager = exports.HTTP_PORTS = exports.DEFAULT_PORT_TYPE = exports.HTTP_PORT_TYPE = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const clusterService_1 = require("./clusterService");
+const storageService_1 = require("./storageService");
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const BlockInstanceRunner_1 = require("./utils/BlockInstanceRunner");
+const utils_1 = require("./utils/utils");
+exports.HTTP_PORT_TYPE = 'http';
+exports.DEFAULT_PORT_TYPE = exports.HTTP_PORT_TYPE;
+exports.HTTP_PORTS = [exports.HTTP_PORT_TYPE, 'web', 'rest'];
+class ServiceManager {
+    _systems;
+    constructor() {
+        this._systems = storageService_1.storageService.get('services');
+        if (!this._systems) {
+            this._systems = {};
+        }
+        lodash_1.default.forEach(this._systems, (system) => {
+            lodash_1.default.forEach(system, (services) => {
+                lodash_1.default.forEach(services, (portInfo) => {
+                    clusterService_1.clusterService.reservePort(portInfo.port);
+                });
+            });
+        });
+    }
+    _forLocal(port, path, environmentType) {
+        if (!path) {
+            path = '';
+        }
+        const hostname = (0, utils_1.getRemoteHostForEnvironment)(environmentType);
+        if (path.startsWith('/')) {
+            path = path.substring(1);
+        }
+        return `http://${hostname}:${port}/${path}`;
+    }
+    _ensureSystem(systemId) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        if (!this._systems[systemId]) {
+            this._systems[systemId] = {};
+        }
+        return this._systems[systemId];
+    }
+    _ensureService(systemId, serviceId) {
+        const system = this._ensureSystem(systemId);
+        if (!system[serviceId]) {
+            system[serviceId] = {};
+        }
+        return system[serviceId];
+    }
+    async ensureServicePort(systemId, blockInstanceId, portType = exports.DEFAULT_PORT_TYPE) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        if (!portType) {
+            portType = exports.DEFAULT_PORT_TYPE;
+        }
+        portType = (0, BlockInstanceRunner_1.resolvePortType)(portType);
+        const service = this._ensureService(systemId, blockInstanceId);
+        if (!service[portType]) {
+            const port = await clusterService_1.clusterService.getNextAvailablePort();
+            service[portType] = { port };
+            this._save();
+        }
+        const portTypeSection = service[portType];
+        return portTypeSection.port;
+    }
+    _save() {
+        storageService_1.storageService.put('services', this._systems);
+    }
+    /**
+     * Gets the consumable address of a service block resource
+     *
+     * This returns a local proxy path to allow traffic inspection and control.
+     *
+     */
+    getConsumerAddress(systemId, consumerInstanceId, consumerResourceName, portType, environmentType) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        const port = clusterService_1.clusterService.getClusterServicePort();
+        const path = clusterService_1.clusterService.getProxyPath(systemId, consumerInstanceId, consumerResourceName, portType);
+        return this._forLocal(port, path, environmentType);
+    }
+    /**
+     * Gets the direct address of a service block
+     *
+     * This returns the actual endpoint address of a service that we're talking to.
+     * For local services this address will be on localhost - for remote services it will
+     * be their remotely available address.
+     *
+     */
+    async getProviderAddress(systemId, providerInstanceId, portType) {
+        systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        const port = await this.ensureServicePort(systemId, providerInstanceId, portType);
+        return this._forLocal(port);
+    }
+    getServices() {
+        return this._systems;
+    }
+}
+exports.serviceManager = new ServiceManager();

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

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+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 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;
+    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;
+    private _bindIO;
+    private _handleSocketCreated;
+    private _bindSocket;
+    private handleJoinRoom;
+    private handleLeaveRoom;
+}
+export declare const socketManager: SocketManager;