@kapeta/local-cluster-service 0.37.0 → 0.38.0

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.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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/esm/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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.37.0",
+    "version": "0.38.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -35,7 +35,8 @@
     },
     "scripts": {
         "start": "node ./dist/cjs/start.js",
-        "dev": "nodemon -e js,ts,json ./start.ts",
+        "dev": "npm run start:dev",
+        "start:dev": "nodemon -e js,ts,json ./start.ts",
         "test": "jest",
         "clean": "rm -rf ./dist",
         "build:esm": "tsc --module nodenext --moduleResolution nodenext --outDir ./dist/esm && echo '{\"type\":\"module\"}' > ./dist/esm/package.json",
@@ -47,19 +48,19 @@
     },
     "homepage": "https://github.com/kapetacom/local-cluster-service#readme",
     "dependencies": {
-        "@kapeta/codegen": "^1.2.1",
-        "@kapeta/kaplang-core": "^1.9.3",
+        "@kapeta/codegen": "^1.3.0",
+        "@kapeta/kaplang-core": "^1.11.2",
         "@kapeta/local-cluster-config": "^0.4.0",
-        "@kapeta/nodejs-api-client": ">=0.1.3 <2",
-        "@kapeta/nodejs-process": "<2",
-        "@kapeta/nodejs-registry-utils": ">=0.9.4 <2",
+        "@kapeta/nodejs-api-client": ">=0.2.0 <2",
+        "@kapeta/nodejs-process": "^1.2.0",
+        "@kapeta/nodejs-registry-utils": ">=0.10.0 <2",
         "@kapeta/nodejs-utils": "<2",
-        "@kapeta/schemas": "^2.0.0",
-        "@kapeta/sdk-config": "^2.0.0",
-        "@kapeta/ui-web-components": "^3.0.1",
-        "@kapeta/ui-web-plan-editor": "^2.0.0",
-        "@kapeta/ui-web-types": "^1.2.0",
-        "@kapeta/web-microfrontend": "^1",
+        "@kapeta/schemas": "^3.4.0",
+        "@kapeta/sdk-config": "^2.1.0",
+        "@kapeta/ui-web-components": "^3.1.0",
+        "@kapeta/ui-web-plan-editor": "^2.3.1",
+        "@kapeta/ui-web-types": "^1.3.1",
+        "@kapeta/web-microfrontend": "^1.2.5",
         "@sentry/node": "^7.94.1",
         "@types/dockerode": "^3.3.19",
         "@types/stream-json": "^1.7.3",

package/src/assetManager.ts

@@ -8,13 +8,13 @@ import FS from 'fs-extra';
 import YAML from 'yaml';
 import { Definition, DefinitionInfo } from '@kapeta/local-cluster-config';
 import { codeGeneratorManager } from './codeGeneratorManager';
-import { ProgressListener } from './progressListener';
+import { ProgressListener, TaskProgressListener } from './progressListener';
 import { normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import { repositoryManager } from './repositoryManager';
 import { BlockDefinition, BlockInstance, Plan } from '@kapeta/schemas';
 import { Actions } from '@kapeta/nodejs-registry-utils';
 import { definitionsManager } from './definitionsManager';
-import { taskManager } from './taskManager';
+import { Task, taskManager } from './taskManager';
 import { KIND_BLOCK_TYPE_EXECUTABLE, KIND_BLOCK_TYPE_OPERATOR, KIND_BLOCK_TYPE, SourceOfChange } from './types';
 import { cacheManager } from './cacheManager';
 import uuid from 'node-uuid';
@@ -308,11 +308,12 @@ class AssetManager {
         }
 
         console.log('Installing updates', refs);
-        const updateAll = async () => {
+        const updateAll = async (task: Task) => {
+            const progressListener = new TaskProgressListener(task);
             try {
                 //We change to a temp dir to avoid issues with the current working directory
                 process.chdir(os.tmpdir());
-                await Actions.install(new ProgressListener(), refs, {});
+                await Actions.install(progressListener, refs, {});
                 await this.cleanupUnusedProviders();
             } catch (e) {
                 console.error(`Failed to update assets: ${refs.join(',')}`, e);