@kapeta/local-cluster-service 0.36.1 → 0.38.0

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

@@ -6,6 +6,10 @@ import express from 'express';
 import { Connection, Resource } from '@kapeta/schemas';
 import { StringBodyRequest } from './middleware/stringBody';
 import { KapetaRequest } from './middleware/kapeta';
+export declare const KIND_RESOURCE_OPERATOR = "core/resource-type-operator";
+export declare const KIND_BLOCK_TYPE = "core/block-type";
+export declare const KIND_BLOCK_TYPE_OPERATOR = "core/block-type-operator";
+export declare const KIND_BLOCK_TYPE_EXECUTABLE = "core/block-type-executable";
 export type StringMap = {
     [key: string]: string;
 };
@@ -62,25 +66,6 @@ export interface Health {
     timeout?: number;
     retries?: number;
 }
-export type PortInfo = {
-    port: number;
-    type: 'tcp' | 'udp';
-} | number | string;
-export type LocalImageOptions<Credentials = AnyMap, Options = AnyMap> = {
-    image: string;
-    ports: {
-        [key: string]: PortInfo;
-    };
-    credentials?: Credentials;
-    options?: Options;
-    cmd?: string;
-    env?: AnyMap;
-    health?: Health;
-    singleton?: boolean;
-    mounts?: {
-        [key: string]: string;
-    };
-};
 export type InstanceInfo = {
     systemId: string;
     instanceId: string;

package/dist/cjs/src/types.js

@@ -4,7 +4,11 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DesiredInstanceStatus = exports.InstanceStatus = exports.InstanceOwner = exports.InstanceType = void 0;
+exports.DesiredInstanceStatus = exports.InstanceStatus = exports.InstanceOwner = exports.InstanceType = exports.KIND_BLOCK_TYPE_EXECUTABLE = exports.KIND_BLOCK_TYPE_OPERATOR = exports.KIND_BLOCK_TYPE = exports.KIND_RESOURCE_OPERATOR = void 0;
+exports.KIND_RESOURCE_OPERATOR = 'core/resource-type-operator';
+exports.KIND_BLOCK_TYPE = 'core/block-type';
+exports.KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
+exports.KIND_BLOCK_TYPE_EXECUTABLE = 'core/block-type-executable';
 var InstanceType;
 (function (InstanceType) {
     InstanceType["DOCKER"] = "docker";

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

@@ -19,8 +19,8 @@ const clusterService_1 = require("../clusterService");
 const types_1 = require("../types");
 const definitionsManager_1 = require("../definitionsManager");
 const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
 const taskManager_1 = require("../taskManager");
-const KIND_BLOCK_TYPE_OPERATOR = 'core/block-type-operator';
 const KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
 const KAPETA_INSTANCE_ID = 'KAPETA_INSTANCE_ID';
@@ -115,7 +115,7 @@ class BlockInstanceRunner {
             throw new Error(`Kind not found: ${kindUri.id}`);
         }
         let processInfo;
-        if (providerVersion.definition.kind === KIND_BLOCK_TYPE_OPERATOR) {
+        if (providerVersion.definition.kind === types_1.KIND_BLOCK_TYPE_OPERATOR) {
             processInfo = await this._startOperatorProcess(blockInstance, blockUri, providerVersion, env);
         }
         else {
@@ -145,6 +145,7 @@ class BlockInstanceRunner {
         if (!assetVersion.definition.spec?.target?.kind) {
             throw new Error('Missing target kind in block definition');
         }
+        const realLocalPath = await fs_extra_1.default.realpath(baseDir);
         const kindUri = (0, nodejs_utils_1.parseKapetaUri)(assetVersion.definition.kind);
         const providerVersion = await getProvider(kindUri);
         if (!providerVersion) {
@@ -159,10 +160,21 @@ class BlockInstanceRunner {
         if (!localContainer) {
             throw new Error(`Missing local container information from target: ${targetKindUri.id}`);
         }
-        const dockerImage = localContainer.image;
-        if (!dockerImage) {
+        let dockerImage = localContainer.image;
+        const isDockerImage = !localContainer.type || localContainer.type.toLowerCase() === 'docker';
+        const isDockerFile = Boolean(localContainer.type && localContainer.type.toLowerCase() === 'dockerfile');
+        if (isDockerImage && !dockerImage) {
             throw new Error(`Missing docker image information: ${JSON.stringify(localContainer)}`);
         }
+        if (isDockerFile) {
+            dockerImage = blockInfo.fullName + ':local';
+            const dockerFile = node_path_1.default.join(realLocalPath, localContainer.file ?? 'Dockerfile');
+            if (!fs_extra_1.default.existsSync(dockerFile)) {
+                throw new Error(`Dockerfile not found at: ${dockerFile}`);
+            }
+            const task = containerManager_1.containerManager.buildDockerImage(dockerFile, blockInfo.fullName + ':local');
+            await task.wait();
+        }
         const containerName = await (0, utils_1.getBlockInstanceContainerName)(this._systemId, blockInstance.id, targetKindUri.id);
         const startCmd = localContainer.handlers?.onCreate ? localContainer.handlers.onCreate : '';
         const dockerOpts = localContainer.options ?? {};
@@ -181,7 +193,6 @@ class BlockInstanceRunner {
         if (localContainer.healthcheck) {
             HealthCheck = containerManager_1.containerManager.toDockerHealth({ cmd: localContainer.healthcheck });
         }
-        const realLocalPath = await fs_extra_1.default.realpath(baseDir);
         const Mounts = containerManager_1.containerManager.toDockerMounts({
             [workingDir]: (0, containerManager_1.toLocalBindVolume)(realLocalPath),
         });

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

@@ -2,6 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+import { Task } from '../taskManager';
 export declare function hasCLI(): Promise<boolean>;
-export declare function ensureCLI(): Promise<import("../taskManager").Task<void> | null>;
+export declare function ensureCLI(): Promise<Task<void> | null>;
 export declare function ensureCLICommands(): Promise<void>;

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

@@ -15,10 +15,16 @@ async function ensureCLI() {
     if (await hasCLI()) {
         return null;
     }
-    return taskManager_1.taskManager.add(`cli:install`, () => {
+    return taskManager_1.taskManager.add(`cli:install`, (task) => {
         const process = (0, nodejs_process_1.spawn)('npm', ['install', '-g', '@kapeta/kap'], {
             shell: true,
         });
+        process.process.stdout?.on('data', (data) => {
+            task.addLog(data.toString(), 'INFO');
+        });
+        process.process.stderr?.on('data', (data) => {
+            task.addLog(data.toString(), 'ERROR');
+        });
         return process.wait();
     }, {
         name: `Installing Kapeta CLI`,

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

@@ -2,10 +2,10 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { EntityList } from '@kapeta/schemas';
-import { AnyMap, PortInfo } from '../types';
+import { EntityList, LocalInstancePort } from '@kapeta/schemas';
+import { AnyMap } from '../types';
 export declare function getBlockInstanceContainerName(systemId: string, instanceId: string, blockType?: string): Promise<string>;
-export declare function toPortInfo(port: PortInfo): {
+export declare function toPortInfo(port: LocalInstancePort): LocalInstancePort | {
     port: number;
     type: string;
 };

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

@@ -11,11 +11,12 @@ exports.getResolvedConfiguration = exports.getBindHost = exports.isLinux = expor
 const node_fs_1 = __importDefault(require("node:fs"));
 const yaml_1 = __importDefault(require("yaml"));
 const md5_1 = __importDefault(require("md5"));
+const schemas_1 = require("@kapeta/schemas");
 const lodash_1 = __importDefault(require("lodash"));
+const types_1 = require("../types");
 const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
 const definitionsManager_1 = require("../definitionsManager");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
-const operatorManager_1 = require("../operatorManager");
 const assetManager_1 = require("../assetManager");
 async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
     if (!blockType) {
@@ -33,7 +34,7 @@ async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
     if (!typeDefinition) {
         throw new Error(`Block type ${blockType} not found`);
     }
-    if ((0, nodejs_utils_1.parseKapetaUri)(typeDefinition.definition.kind).fullName === operatorManager_1.KIND_BLOCK_OPERATOR &&
+    if ((0, nodejs_utils_1.parseKapetaUri)(typeDefinition.definition.kind).fullName === types_1.KIND_BLOCK_TYPE_OPERATOR &&
         typeDefinition.definition.spec?.local?.singleton) {
         return `kapeta-instance-operator-${(0, md5_1.default)((0, nodejs_utils_1.normalizeKapetaUri)(systemId) + (0, nodejs_utils_1.normalizeKapetaUri)(blockType))}`;
     }
@@ -45,7 +46,7 @@ function toPortInfo(port) {
         return { port: parseInt(`${port}`), type: 'tcp' };
     }
     if (!port.type) {
-        port.type = 'tcp';
+        port.type = schemas_1.LocalInstancePortType.TCP;
     }
     return port;
 }

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

@@ -4,6 +4,7 @@
  */
 import { Definition } from '@kapeta/local-cluster-config';
 import { BlockDefinition, BlockInstance, Plan } from '@kapeta/schemas';
+import { Task } from './taskManager';
 import { SourceOfChange } from './types';
 export interface EnrichedAsset {
     ref: string;
@@ -31,7 +32,7 @@ declare class AssetManager {
     updateAsset(ref: string, yaml: Definition, sourceOfChange?: SourceOfChange): Promise<void>;
     importFile(filePath: string): Promise<EnrichedAsset[]>;
     unregisterAsset(ref: string): Promise<void>;
-    installAsset(ref: string, wait?: boolean): Promise<import("./taskManager").Task<void>[] | undefined>;
+    installAsset(ref: string, wait?: boolean): Promise<Task<void>[] | undefined>;
     private cleanupUnusedProviders;
     private upgradeAllProviders;
     private maybeGenerateCode;

package/dist/esm/src/assetManager.js

@@ -18,6 +18,7 @@ const repositoryManager_1 = require("./repositoryManager");
 const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
 const definitionsManager_1 = require("./definitionsManager");
 const taskManager_1 = require("./taskManager");
+const types_1 = require("./types");
 const cacheManager_1 = require("./cacheManager");
 const node_uuid_1 = __importDefault(require("node-uuid"));
 const node_os_1 = __importDefault(require("node:os"));
@@ -75,8 +76,9 @@ class AssetManager {
     async getAssets(assetKinds) {
         if (!assetKinds) {
             const blockTypeProviders = await definitionsManager_1.definitionsManager.getDefinitions([
-                'core/block-type',
-                'core/block-type-operator',
+                types_1.KIND_BLOCK_TYPE,
+                types_1.KIND_BLOCK_TYPE_OPERATOR,
+                types_1.KIND_BLOCK_TYPE_EXECUTABLE,
             ]);
             assetKinds = blockTypeProviders.map((p) => {
                 return `${p.definition.metadata.name}:${p.version}`;
@@ -231,11 +233,12 @@ class AssetManager {
             return;
         }
         console.log('Installing updates', refs);
-        const updateAll = async () => {
+        const updateAll = async (task) => {
+            const progressListener = new progressListener_1.TaskProgressListener(task);
             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(new progressListener_1.ProgressListener(), refs, {});
+                await nodejs_registry_utils_1.Actions.install(progressListener, refs, {});
                 await this.cleanupUnusedProviders();
             }
             catch (e) {

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

@@ -5,7 +5,9 @@
 /// <reference types="node" />
 import FSExtra from 'fs-extra';
 import Docker from 'dockerode';
-import { Health, InstanceInfo, LogEntry } from './types';
+import { InstanceInfo, LogEntry } from './types';
+import { Task } from './taskManager';
+import { LocalInstanceHealth } from '@kapeta/schemas';
 type StringMap = {
     [key: string]: string;
 };
@@ -50,11 +52,11 @@ declare class ContainerManager {
     getContainerByName(containerName: string): Promise<ContainerInfo | undefined>;
     pull(image: string): Promise<boolean>;
     toDockerMounts(mounts: StringMap): DockerMounts[];
-    toDockerHealth(health: Health): {
+    toDockerHealth(health: LocalInstanceHealth): {
         Test: string[];
         Interval: number;
         Timeout: number;
-        Retries: number;
+        Retries: any;
     };
     private applyHash;
     ensureContainer(opts: any): Promise<Docker.Container>;
@@ -74,6 +76,7 @@ declare class ContainerManager {
     getLogs(instance: InstanceInfo): Promise<LogEntry[]>;
     stopLogListening(systemId: string, instanceId: string): Promise<void>;
     ensureLogListening(systemId: string, instanceId: string, handler: (log: LogEntry) => void): Promise<void>;
+    buildDockerImage(dockerFile: string, imageName: string): Task<void>;
 }
 declare class ClosableLogStream {
     private readonly stream;

package/dist/esm/src/containerManager.js

@@ -207,14 +207,8 @@ class ContainerManager {
         return this._docker;
     }
     async getContainerByName(containerName) {
-        const containers = await this.docker().listContainers({ all: true });
-        const out = containers.find((container) => {
-            return container.Names.indexOf(`/${containerName}`) > -1;
-        });
-        if (out) {
-            return this.get(out.Id);
-        }
-        return undefined;
+        // The container can be fetched by name or by id using the same API call
+        return this.get(containerName);
     }
     async pull(image) {
         let [imageName, tag] = image.split(/:/);
@@ -279,6 +273,10 @@ class ContainerManager {
                     };
                 }
                 const chunk = chunks[data.id];
+                if (data.stream) {
+                    // Emit raw output to the task log
+                    task.addLog(data.stream);
+                }
                 switch (data.status) {
                     case DockerPullEventTypes.PreparingPhase:
                     case DockerPullEventTypes.WaitingPhase:
@@ -520,7 +518,7 @@ class ContainerManager {
     async get(name) {
         let dockerContainer = null;
         try {
-            dockerContainer = await this.docker().getContainer(name);
+            dockerContainer = this.docker().getContainer(name);
             await dockerContainer.stats();
         }
         catch (err) {
@@ -545,7 +543,7 @@ class ContainerManager {
                 },
             ];
         }
-        return containerInfo.getLogs();
+        return await containerInfo.getLogs();
     }
     async stopLogListening(systemId, instanceId) {
         const containerName = await (0, utils_1.getBlockInstanceContainerName)(systemId, instanceId);
@@ -616,6 +614,28 @@ class ContainerManager {
             // Ignore
         }
     }
+    buildDockerImage(dockerFile, imageName) {
+        const taskName = `Building docker image: ${imageName}`;
+        const processor = async (task) => {
+            const timeStarted = Date.now();
+            const stream = await this.docker().buildImage({
+                context: path_1.default.dirname(dockerFile),
+                src: [path_1.default.basename(dockerFile)],
+            }, {
+                t: imageName,
+                dockerfile: path_1.default.basename(dockerFile),
+            });
+            await processJsonStream(`image:build:${imageName}`, stream, (data) => {
+                if (data.stream) {
+                    // Emit raw output to the task log
+                    task.addLog(data.stream);
+                }
+            });
+        };
+        return taskManager_1.taskManager.add(`docker:image:build:${imageName}`, processor, {
+            name: taskName,
+        });
+    }
 }
 function readLogBuffer(logBuffer) {
     const out = [];
@@ -830,15 +850,73 @@ class ContainerInfo {
             timestamps: true,
         });
         const out = readLogBuffer(logs);
-        if (out.length === 0) {
-            out.push({
-                time: Date.now(),
-                message: 'No logs found for container',
-                level: 'INFO',
-                source: 'stdout',
-            });
+        if (out.length > 0) {
+            return out;
         }
-        return out;
+        const status = await this.status();
+        const healthLogs = status?.Health?.Log
+            ? status?.Health?.Log.map((log) => {
+                return {
+                    source: 'stdout',
+                    level: log.ExitCode === 0 ? 'INFO' : 'ERROR',
+                    time: Date.now(),
+                    message: 'Health check: ' + log.Output,
+                };
+            })
+            : [];
+        if (status?.Running) {
+            return [
+                {
+                    source: 'stdout',
+                    level: 'INFO',
+                    time: Date.now(),
+                    message: 'Container is starting...',
+                },
+                ...healthLogs,
+            ];
+        }
+        if (status?.Restarting) {
+            return [
+                {
+                    source: 'stdout',
+                    level: 'INFO',
+                    time: Date.now(),
+                    message: 'Container is restarting...',
+                },
+                ...healthLogs,
+            ];
+        }
+        if (status?.Paused) {
+            return [
+                {
+                    source: 'stdout',
+                    level: 'INFO',
+                    time: Date.now(),
+                    message: 'Container is paused...',
+                },
+                ...healthLogs,
+            ];
+        }
+        if (status?.Error) {
+            return [
+                {
+                    source: 'stderr',
+                    level: 'ERROR',
+                    time: Date.now(),
+                    message: 'Container failed to start:\n' + status.Error,
+                },
+                ...healthLogs,
+            ];
+        }
+        return [
+            {
+                source: 'stdout',
+                level: 'INFO',
+                time: Date.now(),
+                message: 'Container not running',
+                ...healthLogs,
+            },
+        ];
     }
 }
 exports.ContainerInfo = ContainerInfo;

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

@@ -45,7 +45,23 @@ export declare class InstanceManager {
     private requestInstanceStatus;
     private isSingletonOperator;
     private getKindForAssetRef;
+    /**
+     * Get the kind of an asset. Use the maxDepth parameter to specify how deep to look for the
+     * kind. For example, if maxDepth is 2, the method will look for the kind of the asset and then
+     * the kind of the kind.
+     * @param assetRef The asset reference
+     * @param maxDepth The maximum depth to look for the kind
+     * @returns The kind of the asset or null if not found
+     */
+    private getDeepKindForAssetRef;
     private isUsingKind;
     private getAllInstancesForKind;
+    /**
+     * Get the ids for all block instances except the ones of the specified kind
+     * @param systemId The plan reference id
+     * @param kind The kind to exclude. Can be a string or an array of strings
+     * @returns An array of block instance ids
+     */
+    private getAllInstancesExceptKind;
 }
 export declare const instanceManager: InstanceManager;

package/dist/esm/src/instanceManager.js

@@ -212,7 +212,9 @@ class InstanceManager {
             systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
             const instance = lodash_1.default.find(this._instances, { systemId, instanceId });
             if (instance && instance.owner === types_1.InstanceOwner.EXTERNAL && instance.status !== types_1.InstanceStatus.STOPPED) {
-                instance.status = types_1.InstanceStatus.STOPPED;
+                if (instance.status != types_1.InstanceStatus.FAILED) {
+                    instance.status = types_1.InstanceStatus.STOPPED;
+                }
                 instance.pid = null;
                 instance.health = null;
                 socketManager_1.socketManager.emitSystemEvent(systemId, socketManager_1.EVENT_STATUS_CHANGED, instance);
@@ -230,11 +232,12 @@ class InstanceManager {
             throw new Error(`No blocks found in plan: ${systemId}`);
         }
         return taskManager_1.taskManager.add(`plan:start:${systemId}`, async () => {
-            let promises = [];
-            let errors = [];
-            for (let blockInstance of Object.values(plan.spec.blocks)) {
+            const promises = [];
+            const errors = [];
+            const instanceIds = await this.getAllInstancesExceptKind(systemId, types_1.KIND_BLOCK_TYPE_EXECUTABLE);
+            for (const instanceId of instanceIds) {
                 try {
-                    promises.push(this.start(systemId, blockInstance.id).then((taskOrInstance) => {
+                    promises.push(this.start(systemId, instanceId).then((taskOrInstance) => {
                         if (taskOrInstance instanceof taskManager_1.Task) {
                             return taskOrInstance.wait();
                         }
@@ -449,7 +452,7 @@ class InstanceManager {
                         // Definition not found
                         return Promise.resolve();
                     }
-                    if (operatorManager_1.KIND_RESOURCE_OPERATOR.toLowerCase() !== asset.definition.kind.toLowerCase()) {
+                    if (types_1.KIND_RESOURCE_OPERATOR.toLowerCase() !== asset.definition.kind.toLowerCase()) {
                         // Not an operator
                         return Promise.resolve();
                     }
@@ -500,8 +503,7 @@ class InstanceManager {
                     ];
                     const out = await this.saveInternalInstance({
                         ...instance,
-                        type: types_1.InstanceType.UNKNOWN,
-                        pid: null,
+                        type: types_1.InstanceType.DOCKER,
                         health: null,
                         portType: DEFAULT_HEALTH_PORT_TYPE,
                         status: types_1.InstanceStatus.FAILED,
@@ -621,9 +623,8 @@ class InstanceManager {
                 }
                 if (instance.status !== newStatus) {
                     const oldStatus = instance.status;
-                    const skipUpdate = (newStatus === types_1.InstanceStatus.STOPPED && instance.status === types_1.InstanceStatus.FAILED) ||
-                        ([types_1.InstanceStatus.READY, types_1.InstanceStatus.UNHEALTHY].includes(newStatus) &&
-                            instance.status === types_1.InstanceStatus.STOPPING) ||
+                    const skipUpdate = ([types_1.InstanceStatus.READY, types_1.InstanceStatus.UNHEALTHY].includes(newStatus) &&
+                        instance.status === types_1.InstanceStatus.STOPPING) ||
                         (newStatus === types_1.InstanceStatus.STOPPED &&
                             instance.status === types_1.InstanceStatus.STARTING &&
                             instance.desiredStatus === types_1.DesiredInstanceStatus.RUN);
@@ -636,7 +637,7 @@ class InstanceManager {
                     }
                 }
                 if (instance.desiredStatus === types_1.DesiredInstanceStatus.RUN &&
-                    [types_1.InstanceStatus.STOPPED, types_1.InstanceStatus.FAILED, types_1.InstanceStatus.STOPPING].includes(newStatus)) {
+                    [types_1.InstanceStatus.STOPPED, types_1.InstanceStatus.STOPPING].includes(newStatus)) {
                     //If the instance is stopped but we want it to run, start it
                     try {
                         await this.start(instance.systemId, instance.instanceId);
@@ -707,10 +708,17 @@ class InstanceManager {
                 return types_1.InstanceStatus.READY;
             }
             if (statusType === 'created') {
+                if (state.ExitCode !== 0) {
+                    // Failed during creation
+                    return types_1.InstanceStatus.FAILED;
+                }
                 return types_1.InstanceStatus.STARTING;
             }
             if (statusType === 'exited' || statusType === 'dead') {
-                return types_1.InstanceStatus.STOPPED;
+                if (state.ExitCode === 0) {
+                    return types_1.InstanceStatus.STOPPED;
+                }
+                return types_1.InstanceStatus.FAILED;
             }
             if (statusType === 'removing') {
                 return types_1.InstanceStatus.BUSY;
@@ -776,7 +784,7 @@ class InstanceManager {
         if (!provider) {
             return false;
         }
-        if ((0, nodejs_utils_1.parseKapetaUri)(provider.kind).fullName === operatorManager_1.KIND_BLOCK_OPERATOR) {
+        if ((0, nodejs_utils_1.parseKapetaUri)(provider.kind).fullName === types_1.KIND_BLOCK_TYPE_OPERATOR) {
             const localConfig = provider.data.spec.local;
             return localConfig.singleton ?? false;
         }
@@ -789,6 +797,36 @@ class InstanceManager {
         }
         return block.data.kind;
     }
+    /**
+     * Get the kind of an asset. Use the maxDepth parameter to specify how deep to look for the
+     * kind. For example, if maxDepth is 2, the method will look for the kind of the asset and then
+     * the kind of the kind.
+     * @param assetRef The asset reference
+     * @param maxDepth The maximum depth to look for the kind
+     * @returns The kind of the asset or null if not found
+     */
+    async getDeepKindForAssetRef(assetRef, maxDepth) {
+        if (maxDepth <= 0) {
+            return null;
+        }
+        try {
+            const asset = await assetManager_1.assetManager.getAsset(assetRef);
+            if (!asset || !asset.data.kind) {
+                return null;
+            }
+            if (maxDepth === 1) {
+                return asset.data.kind;
+            }
+            else {
+                // Recurse with the kind of the current block and one less depth
+                return await this.getDeepKindForAssetRef(asset.data.kind, maxDepth - 1);
+            }
+        }
+        catch (error) {
+            console.error('Error fetching kind for assetRef:', assetRef, error);
+            return null;
+        }
+    }
     async isUsingKind(ref, kind) {
         const assetKind = await this.getKindForAssetRef(ref);
         if (!assetKind) {
@@ -809,6 +847,32 @@ class InstanceManager {
         }
         return out;
     }
+    /**
+     * Get the ids for all block instances except the ones of the specified kind
+     * @param systemId The plan reference id
+     * @param kind The kind to exclude. Can be a string or an array of strings
+     * @returns An array of block instance ids
+     */
+    async getAllInstancesExceptKind(systemId, kind) {
+        const plan = await assetManager_1.assetManager.getPlan(systemId);
+        if (!plan?.spec?.blocks) {
+            return [];
+        }
+        const out = [];
+        const excludedKinds = kind instanceof Array ? kind : [kind];
+        for (const block of plan.spec.blocks) {
+            const blockKindOfKind = await this.getDeepKindForAssetRef(block.block.ref, 2);
+            if (!blockKindOfKind) {
+                continue;
+            }
+            const shouldIncludeBlock = excludedKinds.some((excludedKind) => excludedKind === (0, nodejs_utils_1.parseKapetaUri)(blockKindOfKind).fullName) ===
+                false;
+            if (shouldIncludeBlock) {
+                out.push(block.id);
+            }
+        }
+        return out;
+    }
 }
 exports.InstanceManager = InstanceManager;
 exports.instanceManager = new InstanceManager();

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

@@ -4,13 +4,12 @@
  */
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { ContainerInfo } from './containerManager';
-import { EnvironmentType, LocalImageOptions, OperatorInfo } from './types';
-export declare const KIND_RESOURCE_OPERATOR = "core/resource-type-operator";
-export declare const KIND_BLOCK_OPERATOR = "core/block-type-operator";
+import { EnvironmentType, OperatorInfo } from './types';
+import { LocalInstance } from '@kapeta/schemas';
 declare class Operator {
     private readonly _data;
     constructor(data: DefinitionInfo);
-    getLocalData(): LocalImageOptions;
+    getLocalData(): LocalInstance;
     getDefinitionInfo(): DefinitionInfo;
     getCredentials(): any;
 }