@kapeta/local-cluster-service 0.37.0 → 0.38.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.38.0](https://github.com/kapetacom/local-cluster-service/compare/v0.37.0...v0.38.0) (2024-02-24)
+
+
+### Features
+
+* Add support for running local dockerfiles ([2ee08c5](https://github.com/kapetacom/local-cluster-service/commit/2ee08c58eb19666834262d8011c8f901957b5f63))
+
 # [0.37.0](https://github.com/kapetacom/local-cluster-service/compare/v0.36.1...v0.37.0) (2024-02-23)
 
 

package/dist/cjs/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/cjs/src/assetManager.js

@@ -233,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/cjs/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/cjs/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/cjs/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);
@@ -501,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,
@@ -622,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);
@@ -637,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);
@@ -708,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;

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

@@ -4,11 +4,12 @@
  */
 import { DefinitionInfo } from '@kapeta/local-cluster-config';
 import { ContainerInfo } from './containerManager';
-import { EnvironmentType, LocalImageOptions, OperatorInfo } from './types';
+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;
 }

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

@@ -3,11 +3,13 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 /// <reference types="node" />
+import { LogEntry } from './types';
+import { Task } from './taskManager';
 export declare class ProgressListener {
     private readonly systemId;
     private readonly instanceId;
     constructor(systemId?: string, instanceId?: string);
-    private emitLog;
+    protected emitLog(payload: Omit<LogEntry, 'time' | 'source'>): void;
     run(command: string, directory?: string): Promise<{
         exit: number;
         signal: NodeJS.Signals | null;
@@ -22,3 +24,8 @@ export declare class ProgressListener {
     info(msg: string, ...args: any[]): void;
     debug(msg: string, ...args: any[]): void;
 }
+export declare class TaskProgressListener extends ProgressListener {
+    private readonly task;
+    constructor(task: Task);
+    protected emitLog(payload: Omit<LogEntry, 'time' | 'source'>): void;
+}

package/dist/cjs/src/progressListener.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProgressListener = void 0;
+exports.TaskProgressListener = exports.ProgressListener = void 0;
 const nodejs_process_1 = require("@kapeta/nodejs-process");
 const socketManager_1 = require("./socketManager");
 const node_util_1 = require("node:util");
@@ -120,3 +120,14 @@ class ProgressListener {
     }
 }
 exports.ProgressListener = ProgressListener;
+class TaskProgressListener extends ProgressListener {
+    task;
+    constructor(task) {
+        super();
+        this.task = task;
+    }
+    emitLog(payload) {
+        this.task.addLog(payload.message, payload.level);
+    }
+}
+exports.TaskProgressListener = TaskProgressListener;

package/dist/cjs/src/repositoryManager.js

@@ -164,16 +164,17 @@ class RepositoryManager extends node_events_1.EventEmitter {
     async scheduleInstallation(refs) {
         //We make sure to only install one asset at a time - otherwise unexpected things might happen
         const createInstaller = (ref) => {
-            return async () => {
+            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(new progressListener_1.ProgressListener(), [ref], {});
+                    await nodejs_registry_utils_1.Actions.install(progressListener, [ref], {});
                 }
                 catch (e) {
                     console.error(`Failed to install asset: ${ref}`, e);

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

@@ -2,6 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+import { LogLevel } from './types';
 export type TaskRunner<T> = (task: Task<T>) => Promise<T>;
 export declare enum TaskStatus {
     PENDING = "PENDING",
@@ -44,6 +45,7 @@ export declare class Task<T = void> implements TaskData<T> {
     set errorMessage(errorMessage: string | undefined);
     set metadata(metadata: TaskMetadata);
     emitUpdate(): void;
+    addLog(log: string, level?: LogLevel): void;
     wait(): Promise<T>;
     toData(): {
         id: string;

package/dist/cjs/src/taskManager.js

@@ -12,6 +12,7 @@ const socketManager_1 = require("./socketManager");
 const EVENT_TASK_UPDATED = 'task-updated';
 const EVENT_TASK_ADDED = 'task-added';
 const EVENT_TASK_REMOVED = 'task-removed';
+const EVENT_TASK_LOG = 'task-log';
 var TaskStatus;
 (function (TaskStatus) {
     TaskStatus["PENDING"] = "PENDING";
@@ -54,6 +55,14 @@ class Task {
     emitUpdate() {
         socketManager_1.socketManager.emitGlobal(EVENT_TASK_UPDATED, this.toData());
     }
+    addLog(log, level = 'INFO') {
+        socketManager_1.socketManager.emitGlobal(EVENT_TASK_LOG, {
+            id: this.id,
+            message: log,
+            level,
+            time: Date.now(),
+        });
+    }
     async wait() {
         return this.future.promise;
     }

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

@@ -66,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/utils/BlockInstanceRunner.js

@@ -19,6 +19,7 @@ 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 KAPETA_SYSTEM_ID = 'KAPETA_SYSTEM_ID';
 const KAPETA_BLOCK_REF = 'KAPETA_BLOCK_REF';
@@ -144,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) {
@@ -158,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 ?? {};
@@ -180,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,6 +11,7 @@ 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"));
@@ -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

@@ -233,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;