@kapeta/local-cluster-service 0.37.0 → 0.39.0

package/dist/esm/src/utils/InternalConfigProvider.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInternalConfigProvider = exports.InternalConfigProvider = void 0;
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const configManager_1 = require("../configManager");
+const lodash_1 = __importDefault(require("lodash"));
+const serviceManager_1 = require("../serviceManager");
+const operatorManager_1 = require("../operatorManager");
+const instanceManager_1 = require("../instanceManager");
+const definitionsManager_1 = require("../definitionsManager");
+const utils_1 = require("./utils");
+/**
+ * A configuration provider that does the same as the LocalConfigProvider
+ * but without calling the API of the local cluster service (since it's running in the same process)
+ */
+class InternalConfigProvider {
+    info;
+    systemId;
+    instanceId;
+    config;
+    environment;
+    constructor(systemId, instanceId, info, config, environment = 'docker') {
+        this.info = info;
+        this.systemId = (0, nodejs_utils_1.normalizeKapetaUri)(systemId);
+        this.instanceId = instanceId;
+        this.config = config;
+        this.environment = environment;
+    }
+    getBlockDefinition() {
+        return this.info.definition;
+    }
+    getBlockReference() {
+        return (0, nodejs_utils_1.normalizeKapetaUri)(this.info.definition.metadata.name + ':' + this.info.version);
+    }
+    getSystemId() {
+        return this.systemId;
+    }
+    getInstanceId() {
+        return this.instanceId;
+    }
+    getServerPort(portType) {
+        return serviceManager_1.serviceManager.ensureServicePort(this.systemId, this.instanceId, portType);
+    }
+    async getServiceAddress(serviceName, portType) {
+        return serviceManager_1.serviceManager.getConsumerAddress(this.systemId, this.instanceId, serviceName, portType, this.environment);
+    }
+    getResourceInfo(resourceType, portType, resourceName) {
+        return operatorManager_1.operatorManager.getConsumerResourceInfo(this.systemId, this.instanceId, resourceType, portType, resourceName, this.environment, false);
+    }
+    async getInstanceHost(instanceId) {
+        const instance = instanceManager_1.instanceManager.getInstance(this.systemId, instanceId);
+        return instance?.address ?? null;
+    }
+    async getServerHost() {
+        return (0, utils_1.getBindAddressForEnvironment)(this.environment);
+    }
+    getProviderId() {
+        return 'internal';
+    }
+    getOrDefault(path, defaultValue) {
+        return this.get(path) ?? defaultValue;
+    }
+    get(path) {
+        return lodash_1.default.get(this.config, path);
+    }
+    getInstanceOperator(instanceId) {
+        return instanceManager_1.instanceManager.getInstanceOperator(this.systemId, instanceId, this.environment, false);
+    }
+    async getInstanceForConsumer(resourceName) {
+        const plan = await this.getPlan();
+        if (!plan) {
+            throw new Error('Could not find plan');
+        }
+        const instanceId = this.getInstanceId();
+        const connection = plan.spec.connections.find((connection) => connection.consumer.blockId === instanceId && connection.consumer.resourceName === resourceName);
+        if (!connection) {
+            throw new Error(`Could not find connection for consumer ${resourceName}`);
+        }
+        const instance = plan.spec.blocks.find((b) => b.id === connection.provider.blockId);
+        if (!instance) {
+            throw new Error(`Could not find instance ${connection.provider.blockId} in plan`);
+        }
+        const block = await this.getBlock(instance.block.ref);
+        if (!block) {
+            throw new Error(`Could not find block ${instance.block.ref} in plan`);
+        }
+        return {
+            instanceId: connection.provider.blockId,
+            connections: [connection],
+            block: block,
+        };
+    }
+    async getInstancesForProvider(resourceName) {
+        const plan = await this.getPlan();
+        if (!plan) {
+            throw new Error('Could not find plan');
+        }
+        const instanceId = this.getInstanceId();
+        const blockDetails = {};
+        const connections = plan.spec.connections.filter((connection) => connection.provider.blockId === instanceId && connection.provider.resourceName === resourceName);
+        for (const connection of connections) {
+            const blockInstanceId = connection.consumer.blockId;
+            if (blockDetails[blockInstanceId]) {
+                blockDetails[blockInstanceId].connections.push(connection);
+                continue;
+            }
+            const instance = plan.spec.blocks.find((b) => b.id === blockInstanceId);
+            if (!instance) {
+                throw new Error(`Could not find instance ${blockInstanceId} in plan`);
+            }
+            const block = await this.getBlock(instance.block.ref);
+            if (!block) {
+                throw new Error(`Could not find block ${instance.block.ref} in plan`);
+            }
+            blockDetails[blockInstanceId] = {
+                instanceId: blockInstanceId,
+                connections: [connection],
+                block: block,
+            };
+        }
+        return Object.values(blockDetails);
+    }
+    async getBlock(ref) {
+        const definition = await definitionsManager_1.definitionsManager.getDefinition(ref);
+        if (!definition) {
+            throw new Error(`Could not find definition for ${ref}`);
+        }
+        return definition.definition;
+    }
+    async getPlan() {
+        const definition = await definitionsManager_1.definitionsManager.getDefinition(this.systemId);
+        if (!definition) {
+            throw new Error(`Could not find plan ${this.systemId}`);
+        }
+        return definition.definition;
+    }
+}
+exports.InternalConfigProvider = InternalConfigProvider;
+async function createInternalConfigProvider(systemId, instanceId, info) {
+    const config = await configManager_1.configManager.getConfigForBlockInstance(systemId, instanceId);
+    return new InternalConfigProvider(systemId, instanceId, info, config);
+}
+exports.createInternalConfigProvider = createInternalConfigProvider;

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,17 +2,39 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { EntityList } from '@kapeta/schemas';
-import { AnyMap, PortInfo } from '../types';
+import { EntityList, LocalInstance, LocalInstancePort } from '@kapeta/schemas';
+import { AnyMap, EnvironmentType } 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;
 };
+export declare function getOperatorInstancePorts(systemId: string, operatorId: string, local: LocalInstance): Promise<{
+    portType: string;
+    port: number | undefined;
+    hostPort: any;
+    protocol: string | undefined;
+}[]>;
+/**
+ * Gets the hostname where all services are available - including the cluster service.
+ *
+ * For docker this is the internal docker host - otherwise it's the local machine
+ * Assumed to be the same address as the cluster service outside docker.
+ */
+export declare function getRemoteHostForEnvironment(environment: EnvironmentType | undefined): string;
+/**
+ * Get the bind address for the given environment.
+ *
+ * Outside of docker we bind to 127.0.0.1 - inside we bind to everything (0.0.0.0)
+ */
+export declare function getBindAddressForEnvironment(environment: EnvironmentType | undefined, preferredHost?: string): string;
+/**
+ * Get the docker host IP address for port binding.
+ */
+export declare function getDockerHostIp(preferredHost?: string): string;
 export declare function getRemoteUrl(id: string, defautValue: string): any;
 export declare function readYML(path: string): any;
 export declare function isWindows(): boolean;
 export declare function isMac(): boolean;
 export declare function isLinux(): boolean;
-export declare function getBindHost(preferredHost?: string): string;
 export declare function getResolvedConfiguration(entities?: EntityList, config?: AnyMap, globalConfiguration?: AnyMap): AnyMap;

package/dist/esm/src/utils/utils.js

@@ -7,16 +7,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getResolvedConfiguration = exports.getBindHost = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = exports.toPortInfo = exports.getBlockInstanceContainerName = void 0;
+exports.getResolvedConfiguration = exports.isLinux = exports.isMac = exports.isWindows = exports.readYML = exports.getRemoteUrl = exports.getDockerHostIp = exports.getBindAddressForEnvironment = exports.getRemoteHostForEnvironment = exports.getOperatorInstancePorts = exports.toPortInfo = exports.getBlockInstanceContainerName = void 0;
 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 assetManager_1 = require("../assetManager");
+const serviceManager_1 = require("../serviceManager");
+const clusterService_1 = require("../clusterService");
 async function getBlockInstanceContainerName(systemId, instanceId, blockType) {
     if (!blockType) {
         const instance = await assetManager_1.assetManager.getBlockInstance(systemId, instanceId);
@@ -45,11 +48,54 @@ function toPortInfo(port) {
         return { port: parseInt(`${port}`), type: 'tcp' };
     }
     if (!port.type) {
-        port.type = 'tcp';
+        port.type = schemas_1.LocalInstancePortType.TCP;
     }
     return port;
 }
 exports.toPortInfo = toPortInfo;
+async function getOperatorInstancePorts(systemId, operatorId, local) {
+    const localPorts = local.ports ?? {};
+    const promises = Object.entries(localPorts).map(async ([portType, value]) => {
+        const portInfo = toPortInfo(value);
+        const hostPort = await serviceManager_1.serviceManager.ensureServicePort(systemId, operatorId, portType);
+        return {
+            portType,
+            port: portInfo.port,
+            hostPort,
+            protocol: portInfo.type,
+        };
+    });
+    return await Promise.all(promises);
+}
+exports.getOperatorInstancePorts = getOperatorInstancePorts;
+/**
+ * Gets the hostname where all services are available - including the cluster service.
+ *
+ * For docker this is the internal docker host - otherwise it's the local machine
+ * Assumed to be the same address as the cluster service outside docker.
+ */
+function getRemoteHostForEnvironment(environment) {
+    return environment === 'docker' ? types_1.DOCKER_HOST_INTERNAL : clusterService_1.clusterService.getClusterServiceHost();
+}
+exports.getRemoteHostForEnvironment = getRemoteHostForEnvironment;
+/**
+ * Get the bind address for the given environment.
+ *
+ * Outside of docker we bind to 127.0.0.1 - inside we bind to everything (0.0.0.0)
+ */
+function getBindAddressForEnvironment(environment, preferredHost = '127.0.0.1') {
+    return environment === 'docker' ? '0.0.0.0' : preferredHost;
+}
+exports.getBindAddressForEnvironment = getBindAddressForEnvironment;
+/**
+ * Get the docker host IP address for port binding.
+ */
+function getDockerHostIp(preferredHost = '127.0.0.1') {
+    // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
+    // TODO: This might pose a security risk - so we should authenticate all requests using a shared secret/nonce that we pass around.
+    return isLinux() ? '0.0.0.0' : preferredHost;
+}
+exports.getDockerHostIp = getDockerHostIp;
 function getRemoteUrl(id, defautValue) {
     const remoteConfig = local_cluster_config_1.default.getClusterConfig().remote;
     return remoteConfig?.[id] ?? defautValue;
@@ -77,12 +123,6 @@ function isLinux() {
     return !isWindows() && !isMac();
 }
 exports.isLinux = isLinux;
-function getBindHost(preferredHost = '127.0.0.1') {
-    // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
-    // TODO: This might pose a security risk - so we should authenticate all requests using a shared secret/nonce that we pass around.
-    return isLinux() ? '0.0.0.0' : preferredHost;
-}
-exports.getBindHost = getBindHost;
 function getResolvedConfiguration(entities, config, globalConfiguration) {
     if (!entities || !globalConfiguration) {
         return config || {};

package/index.ts

@@ -24,7 +24,7 @@ import AttachmentRoutes from './src/attachments/routes';
 import TaskRoutes from './src/tasks/routes';
 import APIRoutes from './src/api';
 import AIRoutes from './src/ai/routes';
-import { getBindHost } from './src/utils/utils';
+import { isLinux } from './src/utils/utils';
 import request from 'request';
 import { repositoryManager } from './src/repositoryManager';
 import { taskManager } from './src/taskManager';
@@ -223,7 +223,10 @@ export default {
                 reject(err);
             });
 
-            const bindHost = getBindHost(host);
+            // On Linux we need to bind to 0.0.0.0 to be able to connect to it from docker containers.
+            // TODO: This might pose a security risk - so we should authenticate all requests using a
+            //       shared secret/nonce that we pass around.
+            const bindHost = isLinux() ? '0.0.0.0' : host;
 
             currentServer.listen(port, bindHost, async () => {
                 try {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.37.0",
+    "version": "0.39.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.11.1 <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.5.0",
+        "@kapeta/sdk-config": "^2.1.1",
+        "@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",
@@ -82,7 +83,8 @@
         "stream-json": "^1.8.0",
         "tar-stream": "^3.1.6",
         "typescript": "^5.1.6",
-        "yaml": "^1.6.0"
+        "yaml": "^1.6.0",
+        "@kapeta/config-mapper": "^1.1.1"
     },
     "devDependencies": {
         "@kapeta/eslint-config": "^0.7.0",

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

package/src/config/routes.ts

@@ -157,7 +157,8 @@ router.get('/consumes/resource/:resourceType/:portType/:name', async (req: Kapet
         req.params.resourceType,
         req.params.portType,
         req.params.name,
-        req.kapeta!.environment
+        req.kapeta!.environment,
+        req.query.ensure !== 'false'
     );
 
     res.send(operatorInfo);
@@ -190,7 +191,8 @@ router.get('/operator/:instanceId', async (req: KapetaRequest, res) => {
     const operatorInfo = await instanceManager.getInstanceOperator(
         req.kapeta!.systemId,
         req.params.instanceId,
-        req.kapeta!.environment
+        req.kapeta!.environment,
+        req.query.ensure !== 'false'
     );
 
     res.send(operatorInfo);

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 { DOCKER_HOST_INTERNAL, 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,
@@ -667,7 +665,9 @@ class ContainerManager {
         const newName = 'deleting-' + uuid.v4();
         // Rename the container first to avoid name conflicts if people start the same container
         await container.rename({ name: newName });
-        await container.remove({ force: !!opts?.force });
+
+        const newContainer = this.docker().getContainer(newName);
+        await newContainer.remove({ force: !!opts?.force });
     }
 
     /**
@@ -679,7 +679,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 +707,7 @@ class ContainerManager {
             ];
         }
 
-        return containerInfo.getLogs();
+        return await containerInfo.getLogs();
     }
 
     async stopLogListening(systemId: string, instanceId: string) {
@@ -782,6 +782,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 +1066,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,
+            ];
+        }
+
+        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,
+            ];
         }
 
-        return out;
+        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,
+            },
+        ];
     }
 }
 
@@ -1057,11 +1146,11 @@ export function getExtraHosts(dockerVersion: string): string[] | undefined {
         const [major, minor] = dockerVersion.split('.');
         if (parseInt(major) >= 20 && parseInt(minor) >= 10) {
             // Docker 20.10+ on Linux supports adding host.docker.internal to point to host-gateway
-            return ['host.docker.internal:host-gateway'];
+            return [`${DOCKER_HOST_INTERNAL}:host-gateway`];
         }
         // Docker versions lower than 20.10 needs an actual IP address. We use the default network bridge which
         // is always 172.17.0.1
-        return ['host.docker.internal:172.17.0.1'];
+        return [`${DOCKER_HOST_INTERNAL}:172.17.0.1`];
     }
 
     return undefined;