@kapeta/local-cluster-service 0.36.1 → 0.38.0

package/.vscode/launch.json

@@ -1,15 +1,19 @@
 {
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
     "version": "0.2.0",
     "configurations": [
         {
             "type": "node",
             "request": "launch",
-            "name": "Launch Program",
+            "name": "Debug Node.js (npm run dev)",
+            "runtimeExecutable": "npm",
+            "runtimeArgs": ["run-script", "dev"],
+            "restart": true,
+            "console": "integratedTerminal",
+            "internalConsoleOptions": "neverOpen",
             "skipFiles": ["<node_internals>/**"],
-            "program": "${workspaceFolder}/start.js"
+            "env": {
+                "NODE_ENV": "development"
+            }
         }
     ]
 }

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [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)
+
+
+### Bug Fixes
+
+* Self review ([50bd377](https://github.com/kapetacom/local-cluster-service/commit/50bd377c41f132fd3f61afb1fc74b823bf60729f))
+* Start debugger as "npm run dev" ([44b745a](https://github.com/kapetacom/local-cluster-service/commit/44b745af75e333056f7b187680f43c786461eb1d))
+
+
+### Features
+
+* Add block-type-executabla ([7426433](https://github.com/kapetacom/local-cluster-service/commit/742643358022c0eb3b6065a42abba00e27dfc2e8))
+* Do not attempt to start instances of kind 'core/block-type-executable' ([9239eaf](https://github.com/kapetacom/local-cluster-service/commit/9239eafc117c98fa215b67e2dd99f5d8f18c2881))
+
 ## [0.36.1](https://github.com/kapetacom/local-cluster-service/compare/v0.36.0...v0.36.1) (2024-02-07)
 
 

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

@@ -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/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.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/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);
@@ -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/cjs/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;
 }

package/dist/cjs/src/operatorManager.js

@@ -7,21 +7,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.operatorManager = exports.KIND_BLOCK_OPERATOR = exports.KIND_RESOURCE_OPERATOR = void 0;
+exports.operatorManager = void 0;
 const path_1 = __importDefault(require("path"));
 const md5_1 = __importDefault(require("md5"));
 const serviceManager_1 = require("./serviceManager");
 const storageService_1 = require("./storageService");
 const containerManager_1 = require("./containerManager");
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const types_1 = require("./types");
 const definitionsManager_1 = require("./definitionsManager");
 const utils_1 = require("./utils/utils");
 const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const lodash_1 = __importDefault(require("lodash"));
 const async_lock_1 = __importDefault(require("async-lock"));
 const taskManager_1 = require("./taskManager");
-exports.KIND_RESOURCE_OPERATOR = 'core/resource-type-operator';
-exports.KIND_BLOCK_OPERATOR = 'core/block-type-operator';
 const KIND_PLAN = 'core/plan';
 class Operator {
     _data;
@@ -52,7 +51,7 @@ class OperatorManager {
      * Get operator definition for resource type
      */
     async getOperator(fullName, version) {
-        const operators = await definitionsManager_1.definitionsManager.getDefinitions([exports.KIND_RESOURCE_OPERATOR, exports.KIND_BLOCK_OPERATOR]);
+        const operators = await definitionsManager_1.definitionsManager.getDefinitions([types_1.KIND_RESOURCE_OPERATOR, types_1.KIND_BLOCK_TYPE_OPERATOR]);
         const operator = operators.find((operator) => operator.definition &&
             operator.definition.metadata &&
             operator.definition.metadata.name &&

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;
     }