@kapeta/local-cluster-service 0.17.0 → 0.19.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.19.0](https://github.com/kapetacom/local-cluster-service/compare/v0.18.0...v0.19.0) (2023-09-03)
+
+
+### Features
+
+* Listen for docker logs when user joins room ([#67](https://github.com/kapetacom/local-cluster-service/issues/67)) ([53bd6b6](https://github.com/kapetacom/local-cluster-service/commit/53bd6b6b6de27dc2f9011887176f270d60a0d9dc))
+
+# [0.18.0](https://github.com/kapetacom/local-cluster-service/compare/v0.17.0...v0.18.0) (2023-09-02)
+
+
+### Features
+
+* Auto-rename sample plan when available ([#66](https://github.com/kapetacom/local-cluster-service/issues/66)) ([d95b844](https://github.com/kapetacom/local-cluster-service/commit/d95b844baff7e5bfceb354c854526881051f2308))
+
 # [0.17.0](https://github.com/kapetacom/local-cluster-service/compare/v0.16.8...v0.17.0) (2023-09-02)
 
 

package/dist/cjs/index.js

@@ -27,6 +27,7 @@ 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 = (0, express_1.default)();
@@ -127,6 +128,7 @@ exports.default = {
             throw new Error(`Cluster service already running on: ${clusterHost}:${clusterPort}.`);
         }
         await clusterService_1.clusterService.init();
+        await authManager_1.authManager.listenForChanges();
         currentServer = createServer();
         const port = clusterService_1.clusterService.getClusterServicePort();
         const host = clusterService_1.clusterService.getClusterServiceHost();
@@ -149,7 +151,7 @@ exports.default = {
                 reject(err);
             });
             const bindHost = (0, utils_1.getBindHost)(host);
-            currentServer.listen(port, bindHost, () => {
+            currentServer.listen(port, bindHost, async () => {
                 try {
                     (0, commandLineUtils_1.ensureCLI)().catch((e) => console.error('Failed to install CLI.', e));
                 }
@@ -158,7 +160,7 @@ exports.default = {
                 }
                 try {
                     // Start installation process for all default providers
-                    repositoryManager_1.repositoryManager.ensureDefaultProviders();
+                    await repositoryManager_1.repositoryManager.ensureDefaultProviders();
                 }
                 catch (e) {
                     console.error('Failed to install default providers.', e);

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

@@ -17,8 +17,8 @@ declare class AssetManager {
      * @param {string[]} [assetKinds]
      * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
      */
-    getAssets(assetKinds?: string[]): EnrichedAsset[];
-    getPlans(): EnrichedAsset[];
+    getAssets(assetKinds?: string[]): Promise<EnrichedAsset[]>;
+    getPlans(): Promise<EnrichedAsset[]>;
     getPlan(ref: string, noCache?: boolean): Promise<Definition>;
     getAsset(ref: string, noCache?: boolean, autoFetch?: boolean): Promise<EnrichedAsset | undefined>;
     createAsset(path: string, yaml: BlockDefinition, sourceOfChange?: SourceOfChange): Promise<EnrichedAsset[]>;

package/dist/cjs/src/assetManager.js

@@ -48,9 +48,9 @@ class AssetManager {
      * @param {string[]} [assetKinds]
      * @returns {{path: *, ref: string, data: *, editable: boolean, kind: *, exists: boolean}[]}
      */
-    getAssets(assetKinds) {
+    async getAssets(assetKinds) {
         if (!assetKinds) {
-            const blockTypeProviders = definitionsManager_1.definitionsManager.getDefinitions([
+            const blockTypeProviders = await definitionsManager_1.definitionsManager.getDefinitions([
                 'core/block-type',
                 'core/block-type-operator',
             ]);
@@ -59,10 +59,10 @@ class AssetManager {
             });
             assetKinds.push('core/plan');
         }
-        const assets = definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
+        const assets = await definitionsManager_1.definitionsManager.getDefinitions(assetKinds);
         return assets.map(enrichAsset);
     }
-    getPlans() {
+    async getPlans() {
         return this.getAssets(['core/plan']);
     }
     async getPlan(ref, noCache = false) {
@@ -82,17 +82,16 @@ class AssetManager {
         if (autoFetch) {
             await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, true);
         }
-        let asset = definitionsManager_1.definitionsManager
-            .getDefinitions()
-            .map(enrichAsset)
-            .find((a) => (0, nodejs_utils_1.parseKapetaUri)(a.ref).equals(uri));
-        if (autoFetch && !asset) {
+        const definitionInfo = await definitionsManager_1.definitionsManager.getDefinition(ref);
+        if (autoFetch && !definitionInfo) {
             throw new Error('Asset not found: ' + ref);
         }
-        if (asset) {
+        if (definitionInfo) {
+            const asset = enrichAsset(definitionInfo);
             cacheManager_1.cacheManager.set(cacheKey, asset, CACHE_TTL);
+            return asset;
         }
-        return asset;
+        return undefined;
     }
     async createAsset(path, yaml, sourceOfChange = 'filesystem') {
         if (await fs_extra_1.default.pathExists(path)) {
@@ -113,7 +112,7 @@ class AssetManager {
         definitionsManager_1.definitionsManager.clearCache();
         console.log(`Created asset at: ${path}`);
         const ref = `kapeta://${yaml.metadata.name}:local`;
-        this.maybeGenerateCode(ref, path, yaml);
+        await this.maybeGenerateCode(ref, path, yaml);
         return asset;
     }
     async updateAsset(ref, yaml, sourceOfChange = 'filesystem') {
@@ -133,7 +132,7 @@ class AssetManager {
         console.log(`Updated asset at: ${asset.ymlPath}`);
         cacheManager_1.cacheManager.remove(toKey(ref));
         definitionsManager_1.definitionsManager.clearCache();
-        this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
+        await this.maybeGenerateCode(asset.ref, asset.ymlPath, yaml);
     }
     async importFile(filePath) {
         if (filePath.startsWith('file://')) {
@@ -152,7 +151,8 @@ class AssetManager {
             cacheManager_1.cacheManager.remove(key);
         });
         definitionsManager_1.definitionsManager.clearCache();
-        return this.getAssets().filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
+        const assets = await this.getAssets();
+        return assets.filter((a) => refs.some((ref) => compareRefs(ref, a.ref)));
     }
     async unregisterAsset(ref) {
         const asset = await this.getAsset(ref, true);
@@ -176,9 +176,9 @@ class AssetManager {
         definitionsManager_1.definitionsManager.clearCache();
         return await repositoryManager_1.repositoryManager.ensureAsset(uri.handle, uri.name, uri.version, false);
     }
-    maybeGenerateCode(ref, ymlPath, block) {
+    async maybeGenerateCode(ref, ymlPath, block) {
         ref = (0, utils_1.normalizeKapetaUri)(ref);
-        if (codeGeneratorManager_1.codeGeneratorManager.canGenerateCode(block)) {
+        if (await codeGeneratorManager_1.codeGeneratorManager.canGenerateCode(block)) {
             const assetTitle = block.metadata.title ? block.metadata.title : (0, nodejs_utils_1.parseKapetaUri)(block.metadata.name).name;
             taskManager_1.taskManager.add(`codegen:${ref}`, async () => {
                 await codeGeneratorManager_1.codeGeneratorManager.generate(ymlPath, block);

package/dist/cjs/src/assets/routes.js

@@ -28,8 +28,8 @@ router.use('/', stringBody_1.stringBody);
 /**
  * Get all local assets available
  */
-router.get('/', (req, res) => {
-    res.send(assetManager_1.assetManager.getAssets([]));
+router.get('/', async (req, res) => {
+    res.send(await assetManager_1.assetManager.getAssets([]));
 });
 /**
  * Get single asset

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

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
+declare class AuthManager extends EventEmitter {
+    private watcher?;
+    private hadToken;
+    constructor();
+    listenForChanges(): void;
+    private hasToken;
+    private handleFileChange;
+}
+export declare const authManager: AuthManager;
+export {};

package/dist/cjs/src/authManager.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authManager = void 0;
+const node_events_1 = require("node:events");
+const node_path_1 = __importDefault(require("node:path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const definitionsManager_1 = require("./definitionsManager");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const socketManager_1 = require("./socketManager");
+class AuthManager extends node_events_1.EventEmitter {
+    watcher;
+    hadToken;
+    constructor() {
+        super();
+        this.hadToken = this.hasToken();
+    }
+    listenForChanges() {
+        const parentDir = node_path_1.default.dirname(local_cluster_config_1.default.getKapetaBasedir());
+        //We watch the parent dir to catch changes to the base dir itself
+        this.watcher = chokidar_1.default.watch(parentDir, {
+            followSymlinks: false,
+            ignorePermissionErrors: true,
+            disableGlobbing: true,
+            persistent: true,
+            ignoreInitial: true,
+            depth: 1,
+            ignored: (path) => {
+                return !path.startsWith(local_cluster_config_1.default.getKapetaBasedir());
+            },
+        });
+        this.watcher.add(local_cluster_config_1.default.getKapetaBasedir());
+        this.watcher.on('all', this.handleFileChange.bind(this));
+        this.watcher.on('error', (error) => {
+            console.log('Error watching repository', error);
+        });
+        this.watcher.on('ready', () => {
+            console.log('Watching for auth changes: %s', local_cluster_config_1.default.getKapetaBasedir());
+        });
+    }
+    hasToken() {
+        const api = new nodejs_api_client_1.KapetaAPI();
+        return api.hasToken();
+    }
+    async handleFileChange(eventName, path) {
+        const hasTokenNow = this.hasToken();
+        if (this.hadToken !== hasTokenNow) {
+            socketManager_1.socketManager.emitGlobal('auth-change', {});
+            if (hasTokenNow) {
+                // Clear the cache in case we need to rewrite the sample plan
+                definitionsManager_1.definitionsManager.clearCache();
+            }
+            this.hadToken = hasTokenNow;
+        }
+    }
+}
+exports.authManager = new AuthManager();

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

@@ -1,7 +1,7 @@
 import { BlockDefinition } from '@kapeta/schemas';
 declare class CodeGeneratorManager {
     reload(): Promise<void>;
-    canGenerateCode(yamlContent: BlockDefinition): boolean;
+    canGenerateCode(yamlContent: BlockDefinition): Promise<boolean>;
     generate(yamlFile: string, yamlContent: BlockDefinition): Promise<void>;
 }
 export declare const codeGeneratorManager: CodeGeneratorManager;

package/dist/cjs/src/codeGeneratorManager.js

@@ -12,7 +12,7 @@ const BLOCK_TYPE_KIND = 'core/block-type';
 class CodeGeneratorManager {
     async reload() {
         codegen_1.registry.reset();
-        const languageTargets = definitionsManager_1.definitionsManager.getDefinitions(TARGET_KIND);
+        const languageTargets = await definitionsManager_1.definitionsManager.getDefinitions(TARGET_KIND);
         for (const languageTarget of languageTargets) {
             const key = `${languageTarget.definition.metadata.name}:${languageTarget.version}`;
             try {
@@ -29,12 +29,12 @@ class CodeGeneratorManager {
             }
         }
     }
-    canGenerateCode(yamlContent) {
+    async canGenerateCode(yamlContent) {
         if (!yamlContent.spec.target?.kind) {
             //Not all block types have targets
             return false;
         }
-        const blockTypes = definitionsManager_1.definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
+        const blockTypes = await definitionsManager_1.definitionsManager.getDefinitions(BLOCK_TYPE_KIND);
         const blockTypeKinds = blockTypes.map((blockType) => blockType.definition.metadata.name.toLowerCase() + ':' + blockType.version);
         return !!(yamlContent && yamlContent.kind && blockTypeKinds.indexOf(yamlContent.kind.toLowerCase()) > -1);
     }

package/dist/cjs/src/configManager.js

@@ -61,7 +61,7 @@ class ConfigManager {
         if (systemId) {
             systemId = (0, utils_1.normalizeKapetaUri)(systemId);
         }
-        const planAssets = assetManager_1.assetManager.getPlans();
+        const planAssets = await assetManager_1.assetManager.getPlans();
         const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockRef);
         let matchingIdentities = [];
         planAssets.forEach((planAsset) => {
@@ -99,7 +99,7 @@ class ConfigManager {
     async verifyIdentity(blockRef, systemId, instanceId) {
         blockRef = (0, utils_1.normalizeKapetaUri)(blockRef);
         systemId = (0, utils_1.normalizeKapetaUri)(systemId);
-        const planAssets = assetManager_1.assetManager.getPlans();
+        const planAssets = await assetManager_1.assetManager.getPlans();
         const systemUri = systemId ? (0, nodejs_utils_1.parseKapetaUri)(systemId) : null;
         const blockUri = (0, nodejs_utils_1.parseKapetaUri)(blockRef);
         let found = false;

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

@@ -1,3 +1,5 @@
+/// <reference types="node" />
+import FSExtra from 'fs-extra';
 import { Docker } from 'node-docker-api';
 import { Container } from 'node-docker-api/lib/container';
 import { InstanceInfo, LogEntry } from './types';
@@ -50,6 +52,7 @@ declare class ContainerManager {
     private _mountDir;
     private _version;
     private _lastDockerAccessCheck;
+    private logStreams;
     constructor();
     initialize(): Promise<void>;
     checkAlive(): Promise<boolean>;
@@ -83,6 +86,17 @@ declare class ContainerManager {
      */
     get(name: string): Promise<ContainerInfo | null>;
     getLogs(instance: InstanceInfo): Promise<LogEntry[]>;
+    stopLogListening(systemId: string, instanceId: string): Promise<void>;
+    ensureLogListening(systemId: string, instanceId: string, handler: (log: LogEntry) => void): Promise<void>;
+}
+declare class ClosableLogStream {
+    private readonly stream;
+    private readonly eventEmitter;
+    constructor(stream: FSExtra.ReadStream);
+    onLog(listener: (log: LogEntry) => void): () => void;
+    onEnd(listener: () => void): () => void;
+    onError(listener: (error: Error) => void): () => void;
+    close(): Promise<void>;
 }
 export declare class ContainerInfo {
     private readonly _container;
@@ -107,6 +121,7 @@ export declare class ContainerInfo {
     inspect(): Promise<any>;
     status(): Promise<DockerState>;
     getPorts(): Promise<PortMap | false>;
+    getLogStream(): Promise<ClosableLogStream>;
     getLogs(): Promise<LogEntry[]>;
 }
 export declare function getExtraHosts(dockerVersion: string): string[] | undefined;

package/dist/cjs/src/containerManager.js

@@ -17,6 +17,7 @@ const md5_1 = __importDefault(require("md5"));
 const utils_1 = require("./utils/utils");
 const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
 const taskManager_1 = require("./taskManager");
+const node_events_1 = require("node:events");
 exports.CONTAINER_LABEL_PORT_PREFIX = 'kapeta_port-';
 const NANO_SECOND = 1000000;
 const HEALTH_CHECK_INTERVAL = 3000;
@@ -33,6 +34,7 @@ class ContainerManager {
     _mountDir;
     _version;
     _lastDockerAccessCheck = 0;
+    logStreams = {};
     constructor() {
         this._docker = null;
         this._alive = false;
@@ -472,6 +474,175 @@ class ContainerManager {
         }
         return containerInfo.getLogs();
     }
+    async stopLogListening(systemId, instanceId) {
+        const containerName = (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
+        if (this.logStreams[containerName]) {
+            if (this.logStreams[containerName]?.timer) {
+                clearTimeout(this.logStreams[containerName].timer);
+            }
+            console.log('Stopped listening for logs on container: %s', containerName);
+            try {
+                const stream = this.logStreams[containerName].stream;
+                if (stream) {
+                    await stream.close();
+                }
+            }
+            catch (err) {
+                // Ignore
+            }
+            delete this.logStreams[containerName];
+        }
+    }
+    async ensureLogListening(systemId, instanceId, handler) {
+        const containerName = (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
+        try {
+            if (this.logStreams[containerName]?.stream) {
+                // Already listening - will shut itself down
+                return;
+            }
+            if (this.logStreams[containerName]?.timer) {
+                clearTimeout(this.logStreams[containerName].timer);
+            }
+            const tryLater = () => {
+                this.logStreams[containerName] = {
+                    timer: setTimeout(() => {
+                        // Keep trying until user decides to not listen anymore
+                        this.ensureLogListening(systemId, instanceId, handler);
+                    }, 5000),
+                };
+            };
+            const containerInfo = await this.getContainerByName(containerName);
+            if (!containerInfo || !(await containerInfo.isRunning())) {
+                // Container not currently running - try again in 5 seconds
+                tryLater();
+                return;
+            }
+            const stream = await containerInfo.getLogStream();
+            stream.onLog((log) => {
+                try {
+                    handler(log);
+                }
+                catch (err) {
+                    console.warn('Error handling log', err);
+                }
+            });
+            stream.onEnd(() => {
+                // We get here if the container is stopped
+                delete this.logStreams[containerName];
+                tryLater();
+            });
+            stream.onError((err) => {
+                // We get here if the container crashes
+                delete this.logStreams[containerName];
+                tryLater();
+            });
+            this.logStreams[containerName] = {
+                stream,
+            };
+        }
+        catch (err) {
+            // Ignore
+        }
+    }
+}
+function readLogBuffer(logBuffer) {
+    const out = [];
+    let offset = 0;
+    while (offset < logBuffer.length) {
+        try {
+            // Read the docker log format - explained here:
+            // https://docs.docker.com/engine/api/v1.41/#operation/ContainerAttach
+            // or here : https://ahmet.im/blog/docker-logs-api-binary-format-explained/
+            // First byte is stream type
+            const streamTypeInt = logBuffer.readInt8(offset);
+            const streamType = streamTypeInt === 1 ? 'stdout' : 'stderr';
+            if (streamTypeInt !== 1 && streamTypeInt !== 2) {
+                console.error('Unknown stream type: %s', streamTypeInt, out[out.length - 1]);
+                break;
+            }
+            // Bytes 4-8 is frame size
+            const messageLength = logBuffer.readInt32BE(offset + 4);
+            // After that is the message - with the message length
+            const dataWithoutStreamType = logBuffer.subarray(offset + 8, offset + 8 + messageLength);
+            const raw = dataWithoutStreamType.toString();
+            // Split the message into date and message
+            const firstSpaceIx = raw.indexOf(' ');
+            const dateString = raw.substring(0, firstSpaceIx);
+            const line = raw.substring(firstSpaceIx + 1);
+            offset = offset + messageLength + 8;
+            if (!dateString) {
+                break;
+            }
+            out.push({
+                time: new Date(dateString).getTime(),
+                message: line,
+                level: 'INFO',
+                source: streamType,
+            });
+        }
+        catch (err) {
+            console.error('Error parsing log entry', err);
+            offset = logBuffer.length;
+            break;
+        }
+    }
+    return out;
+}
+class ClosableLogStream {
+    stream;
+    eventEmitter;
+    constructor(stream) {
+        this.stream = stream;
+        this.eventEmitter = new node_events_1.EventEmitter();
+        stream.on('data', (data) => {
+            const logs = readLogBuffer(data);
+            logs.forEach((log) => {
+                this.eventEmitter.emit('log', log);
+            });
+        });
+        stream.on('end', () => {
+            this.eventEmitter.emit('end');
+        });
+        stream.on('error', (error) => {
+            this.eventEmitter.emit('error', error);
+        });
+        stream.on('close', () => {
+            this.eventEmitter.emit('end');
+        });
+    }
+    onLog(listener) {
+        this.eventEmitter.on('log', listener);
+        return () => {
+            this.eventEmitter.removeListener('log', listener);
+        };
+    }
+    onEnd(listener) {
+        this.eventEmitter.on('end', listener);
+        return () => {
+            this.eventEmitter.removeListener('end', listener);
+        };
+    }
+    onError(listener) {
+        this.eventEmitter.on('error', listener);
+        return () => {
+            this.eventEmitter.removeListener('error', listener);
+        };
+    }
+    close() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.stream.close((err) => {
+                    if (err) {
+                        console.warn('Error closing log stream', err);
+                    }
+                    resolve();
+                });
+            }
+            catch (err) {
+                // Ignore
+            }
+        });
+    }
 }
 class ContainerInfo {
     _container;
@@ -555,52 +726,34 @@ class ContainerInfo {
         });
         return ports;
     }
+    async getLogStream() {
+        try {
+            const logStream = (await this.native.logs({
+                stdout: true,
+                stderr: true,
+                follow: true,
+                tail: 0,
+                timestamps: true,
+            }));
+            return new ClosableLogStream(logStream);
+        }
+        catch (err) {
+            console.log('Error getting log stream', err);
+            throw err;
+        }
+    }
     async getLogs() {
         const logStream = (await this.native.logs({
             stdout: true,
             stderr: true,
             follow: false,
-            tail: 100,
             timestamps: true,
         }));
-        const out = [];
+        const chunks = [];
         await promisifyStream(logStream, (data) => {
-            const buf = data;
-            let offset = 0;
-            while (offset < buf.length) {
-                try {
-                    // Read the docker log format - explained here:
-                    // https://docs.docker.com/engine/api/v1.41/#operation/ContainerAttach
-                    // or here : https://ahmet.im/blog/docker-logs-api-binary-format-explained/
-                    // First byte is stream type
-                    const streamTypeInt = buf.readInt8(offset);
-                    const streamType = streamTypeInt === 1 ? 'stdout' : 'stderr';
-                    // Bytes 4-8 is frame size
-                    const messageLength = buf.readInt32BE(offset + 4);
-                    // After that is the message - with the message length
-                    const dataWithoutStreamType = buf.subarray(offset + 8, offset + 8 + messageLength);
-                    const raw = dataWithoutStreamType.toString();
-                    // Split the message into date and message
-                    const firstSpaceIx = raw.indexOf(' ');
-                    const dateString = raw.substring(0, firstSpaceIx);
-                    const line = raw.substring(firstSpaceIx + 1);
-                    offset = offset + messageLength + 8;
-                    if (!dateString) {
-                        continue;
-                    }
-                    out.push({
-                        time: new Date(dateString).getTime(),
-                        message: line,
-                        level: 'INFO',
-                        source: streamType,
-                    });
-                }
-                catch (err) {
-                    console.error('Error parsing log entry', err);
-                    offset = buf.length;
-                }
-            }
+            chunks.push(data);
         });
+        const out = readLogBuffer(Buffer.concat(chunks));
         if (out.length === 0) {
             out.push({
                 time: Date.now(),

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

@@ -1,11 +1,12 @@
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
+export declare const SAMPLE_PLAN_NAME = "kapeta/sample-nodejs-plan";
 declare class DefinitionsManager {
-    private getHash;
-    private getFullKey;
-    getDefinitions(kindFilter?: string | string[]): DefinitionInfo[];
-    exists(ref: string): boolean;
-    getProviderDefinitions(): DefinitionInfo[];
-    getDefinition(ref: string): DefinitionInfo | undefined;
+    private resolveDefinitionsAndSamples;
+    private applyFilters;
+    getDefinitions(kindFilter?: string | string[]): Promise<DefinitionInfo[]>;
+    exists(ref: string): Promise<boolean>;
+    getProviderDefinitions(): Promise<DefinitionInfo[]>;
+    getDefinition(ref: string): Promise<DefinitionInfo | undefined>;
     clearCache(): void;
 }
 export declare const definitionsManager: DefinitionsManager;