@kapeta/local-cluster-service 0.36.1 → 0.38.0

package/dist/esm/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/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

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

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.36.1",
+    "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/local-cluster-config": ">= 0.3.2 <2",
-        "@kapeta/nodejs-api-client": ">=0.1.3 <2",
-        "@kapeta/nodejs-process": "<2",
-        "@kapeta/nodejs-registry-utils": ">=0.9.4 <2",
+        "@kapeta/codegen": "^1.3.0",
+        "@kapeta/kaplang-core": "^1.11.2",
+        "@kapeta/local-cluster-config": "^0.4.0",
+        "@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",
@@ -85,8 +86,8 @@
         "yaml": "^1.6.0"
     },
     "devDependencies": {
-        "@kapeta/eslint-config": "^0.6.1",
-        "@kapeta/prettier-config": "^0.6.0",
+        "@kapeta/eslint-config": "^0.7.0",
+        "@kapeta/prettier-config": "^0.6.2",
         "@tsconfig/node18": "^18.2.0",
         "@types/async-lock": "^1.4.0",
         "@types/express": "^4.17.17",

package/src/assetManager.ts

@@ -8,14 +8,14 @@ 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 { SourceOfChange } from './types';
+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';
 import os from 'node:os';
@@ -94,8 +94,9 @@ class AssetManager {
     async getAssets(assetKinds?: string[]): Promise<EnrichedAsset[]> {
         if (!assetKinds) {
             const blockTypeProviders = await definitionsManager.getDefinitions([
-                'core/block-type',
-                'core/block-type-operator',
+                KIND_BLOCK_TYPE,
+                KIND_BLOCK_TYPE_OPERATOR,
+                KIND_BLOCK_TYPE_EXECUTABLE,
             ]);
             assetKinds = blockTypeProviders.map((p) => {
                 return `${p.definition.metadata.name}:${p.version}`;
@@ -307,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);

package/src/containerManager.ts

@@ -14,12 +14,12 @@ import ClusterConfiguration from '@kapeta/local-cluster-config';
 import uuid from 'node-uuid';
 import md5 from 'md5';
 import { getBlockInstanceContainerName } from './utils/utils';
-import { Health, InstanceInfo, LogEntry, LogSource } from './types';
+import { InstanceInfo, LogEntry, LogSource } from './types';
 import { KapetaAPI } from '@kapeta/nodejs-api-client';
 import { taskManager, Task } from './taskManager';
 import { EventEmitter } from 'node:events';
 import StreamValues from 'stream-json/streamers/StreamValues';
-import { Stream } from 'stream';
+import { LocalInstanceHealth } from '@kapeta/schemas';
 
 type StringMap = { [key: string]: string };
 
@@ -100,7 +100,7 @@ enum DockerPullEventTypes {
 
 type DockerPullEventType = DockerPullEventTypes | string;
 
-const processJsonStream = <T>(purpose: string, stream: Stream, handler: (d: JSONMessage<T>) => void) =>
+const processJsonStream = <T>(purpose: string, stream: NodeJS.ReadableStream, handler: (d: JSONMessage<T>) => void) =>
     new Promise<void>((resolve, reject) => {
         const jsonStream = StreamValues.withParser();
         jsonStream.on('data', (data: any) => {
@@ -296,15 +296,8 @@ class ContainerManager {
     }
 
     async getContainerByName(containerName: string): Promise<ContainerInfo | undefined> {
-        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: string) {
@@ -398,6 +391,11 @@ 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:
@@ -529,7 +527,7 @@ class ContainerManager {
         return Mounts;
     }
 
-    toDockerHealth(health: Health) {
+    toDockerHealth(health: LocalInstanceHealth) {
         return {
             Test: ['CMD-SHELL', health.cmd],
             Interval: health.interval ? health.interval * NANO_SECOND : 5000 * NANO_SECOND,
@@ -679,7 +677,7 @@ class ContainerManager {
         let dockerContainer = null;
 
         try {
-            dockerContainer = await this.docker().getContainer(name);
+            dockerContainer = this.docker().getContainer(name);
             await dockerContainer.stats();
         } catch (err) {
             //Ignore
@@ -707,7 +705,7 @@ class ContainerManager {
             ];
         }
 
-        return containerInfo.getLogs();
+        return await containerInfo.getLogs();
     }
 
     async stopLogListening(systemId: string, instanceId: string) {
@@ -782,6 +780,34 @@ class ContainerManager {
             // Ignore
         }
     }
+
+    buildDockerImage(dockerFile: string, imageName: string) {
+        const taskName = `Building docker image: ${imageName}`;
+        const processor = async (task: Task) => {
+            const timeStarted = Date.now();
+            const stream = await this.docker().buildImage(
+                {
+                    context: Path.dirname(dockerFile),
+                    src: [Path.basename(dockerFile)],
+                },
+                {
+                    t: imageName,
+                    dockerfile: Path.basename(dockerFile),
+                }
+            );
+
+            await processJsonStream<string>(`image:build:${imageName}`, stream, (data) => {
+                if (data.stream) {
+                    // Emit raw output to the task log
+                    task.addLog(data.stream);
+                }
+            });
+        };
+
+        return taskManager.add(`docker:image:build:${imageName}`, processor, {
+            name: taskName,
+        });
+    }
 }
 
 function readLogBuffer(logBuffer: Buffer) {
@@ -1038,17 +1064,78 @@ export class ContainerInfo {
         });
 
         const out = readLogBuffer(logs);
+        if (out.length > 0) {
+            return out;
+        }
 
-        if (out.length === 0) {
-            out.push({
-                time: Date.now(),
-                message: 'No logs found for container',
-                level: 'INFO',
-                source: 'stdout',
-            });
+        const status = await this.status();
+        const healthLogs: LogEntry[] = 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,
+            ];
         }
 
-        return out;
+        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,
+            },
+        ];
     }
 }