hammerkit 1.5.1 → 1.6.0-alpha.2

package/dist/planner/{work-node-status.js → work-item-status.js}

@@ -2,102 +2,56 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.statusConsole = exports.logContext = void 0;
 const emitter_1 = require("../utils/emitter");
-const work_node_1 = require("./work-node");
 const environment_config_1 = require("../utils/environment-config");
 const log_1 = require("../log");
+const buffer_context_1 = require("../utils/buffer-context");
 const StatusBufferMax = (0, environment_config_1.getEnvironmentConfig)('STATUS_BUFFER_LIMIT', 300);
 const ConsoleBufferMax = (0, environment_config_1.getEnvironmentConfig)('CONSOLE_BUFFER_LIMIT', 30);
-function logContext(type, node) {
+function logContext(type, item) {
     return {
         type,
-        name: node.name,
-        id: node.id,
+        name: item.name,
     };
 }
 exports.logContext = logContext;
-class BufferContext {
-    constructor(limit) {
-        this.limit = limit;
-        this.scopedBuffer = {};
-        this.buffer = [];
-    }
-    add(id, data) {
-        this.buffer.push(data);
-        if (id in this.scopedBuffer) {
-            const scopedBuffer = this.scopedBuffer[id];
-            scopedBuffer.push(data);
-            if (scopedBuffer.length > this.limit) {
-                const removedBuffer = this.buffer.splice(0, 1)[0];
-                const bufferIndex = this.buffer.indexOf(removedBuffer);
-                if (bufferIndex >= 0) {
-                    this.buffer.splice(bufferIndex, 1);
-                }
-            }
-        }
-        else {
-            this.scopedBuffer[id] = [data];
-        }
-    }
-    current(id) {
-        if (!(id in this.scopedBuffer)) {
-            return null;
-        }
-        const value = this.scopedBuffer[id];
-        return value[value.length - 1];
-    }
-    get(id) {
-        if (id) {
-            return this.scopedBuffer[id] ?? [];
-        }
-        else {
-            return this.buffer;
-        }
-    }
-}
 function statusConsole(writable) {
-    const statusBuffer = new BufferContext(StatusBufferMax);
-    const consoleBuffer = new BufferContext(ConsoleBufferMax);
+    const statusBuffer = new buffer_context_1.BufferContext(StatusBufferMax);
+    const consoleBuffer = new buffer_context_1.BufferContext(ConsoleBufferMax);
     const emit = (0, emitter_1.emitter)();
     function addMessage(context, message) {
         emit.emit(message);
         writable.write(JSON.stringify({ context, message }) + '\n');
         if (message.type === 'console') {
-            consoleBuffer.add(context.id, message);
+            consoleBuffer.add(context.name, message);
         }
         else if (log_1.isVerbose || message.level !== 'debug') {
-            statusBuffer.add(context.id, message);
+            statusBuffer.add(context.name, message);
         }
     }
     return {
-        task(task) {
-            return this.context(logContext('task', task));
-        },
-        service(service) {
-            return this.context(logContext('service', service));
-        },
-        from(node) {
-            if ((0, work_node_1.isWorkNode)(node)) {
-                return this.task(node);
+        from(item) {
+            if (item.type === 'kubernetes-service' || item.type === 'container-service') {
+                return this.context(logContext('service', item));
             }
             else {
-                return this.service(node);
+                return this.context(logContext('task', item));
             }
         },
         context(context) {
             return {
                 currentLog() {
-                    return consoleBuffer.current(context.id);
+                    return consoleBuffer.current(context.name);
                 },
                 current() {
-                    return statusBuffer.current(context.id);
+                    return statusBuffer.current(context.name);
                 },
                 *logs() {
-                    for (const log of consoleBuffer.get(context.id)) {
+                    for (const log of consoleBuffer.get(context.name)) {
                         yield log;
                     }
                 },
                 *read() {
-                    for (const log of statusBuffer.get(context.id)) {
+                    for (const log of statusBuffer.get(context.name)) {
                         yield log;
                     }
                 },
@@ -132,4 +86,4 @@ function statusConsole(writable) {
     };
 }
 exports.statusConsole = statusConsole;
-//# sourceMappingURL=work-node-status.js.map
+//# sourceMappingURL=work-item-status.js.map

package/dist/{parser/build-file-service.js → planner/work-item-validation.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=build-file-service.js.map
+//# sourceMappingURL=work-item-validation.js.map

package/dist/planner/work-item.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKubernetesWorkServiceItem = exports.isContainerWorkServiceItem = exports.isLocalWorkTaskItem = exports.isContainerWorkTaskItem = exports.isWorkTaskItem = exports.isContainerWorkItem = void 0;
+const isContainerWorkItem = (val) => val.data.type === 'container-service' || val.data.type === 'container-task';
+exports.isContainerWorkItem = isContainerWorkItem;
+const isWorkTaskItem = (val) => val.data.type === 'local-task' || val.data.type === 'container-task';
+exports.isWorkTaskItem = isWorkTaskItem;
+const isContainerWorkTaskItem = (val) => val.data.type === 'container-task';
+exports.isContainerWorkTaskItem = isContainerWorkTaskItem;
+const isLocalWorkTaskItem = (val) => val.data.type === 'local-task';
+exports.isLocalWorkTaskItem = isLocalWorkTaskItem;
+const isContainerWorkServiceItem = (val) => val.data.type === 'container-service';
+exports.isContainerWorkServiceItem = isContainerWorkServiceItem;
+const isKubernetesWorkServiceItem = (val) => val.data.type === 'kubernetes-service';
+exports.isKubernetesWorkServiceItem = isKubernetesWorkServiceItem;
+//# sourceMappingURL=work-item.js.map

package/dist/{optimizer/work-node-cache-stats.js → planner/work-kubernetes-selector.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=work-node-cache-stats.js.map
+//# sourceMappingURL=work-kubernetes-selector.js.map

package/dist/planner/{work-nodes.js → work-port.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=work-nodes.js.map
+//# sourceMappingURL=work-port.js.map

package/dist/planner/work-runtime-docker.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dockerServiceRuntime = exports.dockerTaskRuntime = void 0;
+const execute_docker_1 = require("../executer/execute-docker");
+const remove_container_1 = require("../docker/remove-container");
+const docker_task_1 = require("../executer/docker-task");
+const docker_service_1 = require("../executer/docker-service");
+const using_container_1 = require("../docker/using-container");
+const event_cache_1 = require("../executer/event-cache");
+const get_docker_executor_1 = require("../executer/get-docker-executor");
+const path_1 = require("path");
+const plan_work_volume_1 = require("./utils/plan-work-volume");
+function dockerTaskRuntime(task, workEnvironment) {
+    const docker = (0, execute_docker_1.getContainerCli)(workEnvironment);
+    return {
+        async initialize(state) {
+            const currentTasks = await docker.listContainers({
+                filters: {
+                    label: [`hammerkit-id=${task.id()}`],
+                },
+            });
+            const currentTask = currentTasks[0];
+            if (!currentTask) {
+                return;
+            }
+            const taskState = 'hammerkit-state' in currentTask.Labels ? currentTask.Labels['hammerkit-state'] : '';
+            state.set({
+                type: 'error',
+                stateKey: taskState,
+                errorMessage: `Container ${currentTask.Id} already running`,
+            });
+        },
+        async restore(environment, path) {
+            await restoreContainer(docker, environment, task, path);
+        },
+        async archive(environment, path) {
+            await archiveContainer(docker, environment, task, path);
+        },
+        async stop() {
+            const containers = await docker.listContainers({
+                all: true,
+                filters: {
+                    label: [`hammerkit-id=${task.id()}`],
+                },
+            });
+            for (const container of containers) {
+                await (0, remove_container_1.removeContainer)(docker.getContainer(container.Id));
+            }
+        },
+        async execute(environment, options) {
+            await (0, docker_task_1.dockerTask)(docker, task, environment, options);
+        },
+        async remove() {
+            await this.stop();
+            for (const generate of task.data.generates) {
+                if (generate.inherited) {
+                    continue;
+                }
+                const volumeName = (0, plan_work_volume_1.getVolumeName)(generate.path);
+                const volumeExists = await (0, get_docker_executor_1.existsVolume)(docker, volumeName);
+                if (volumeExists) {
+                    await (0, get_docker_executor_1.removeVolume)(docker, task.status, volumeName);
+                }
+                else {
+                    task.status.write('info', `generate ${generate} has no volume ${volumeName}`);
+                }
+            }
+        },
+        async currentStateKey() {
+            const containers = await docker.listContainers({
+                all: true,
+                filters: {
+                    label: [`hammerkit-id=${task.id()}`],
+                },
+            });
+            const container = containers[0];
+            if (!container) {
+                return null;
+            }
+            if (!container.Labels['hammerkit-state']) {
+                return null;
+            }
+            return container.Labels['hammerkit-state'];
+        },
+    };
+}
+exports.dockerTaskRuntime = dockerTaskRuntime;
+async function restoreContainer(docker, environment, item, path) {
+    await (0, using_container_1.usingContainer)(docker, item, {
+        abortSignal: environment.abortCtrl.signal,
+        Image: item.data.image,
+        Tty: true,
+        Entrypoint: ['sh'],
+        Cmd: ['-c', 'sleep 3600'],
+        WorkingDir: (0, execute_docker_1.convertToPosixPath)(item.data.cwd),
+        Labels: {
+            app: 'hammerkit',
+            'hammerkit-id': item.id(),
+            'hammerkit-pid': process.pid.toString(),
+            'hammerkit-type': 'task',
+        },
+        HostConfig: {
+            AutoRemove: true,
+            Binds: item.data.type === 'container-task'
+                ? []
+                : [...item.data.volumes.map((v) => `${v.name}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`)],
+        },
+    }, null, async (container) => {
+        for (const generate of (0, event_cache_1.getArchivePaths)(item.data, path)) {
+            if (await environment.file.exists(generate.filename)) {
+                await container.putArchive(environment.file.readStream(generate.filename), {
+                    path: (0, path_1.dirname)(generate.path),
+                });
+            }
+        }
+    });
+}
+function dockerServiceRuntime(service, workEnvironment) {
+    const docker = (0, execute_docker_1.getContainerCli)(workEnvironment);
+    return {
+        async initialize(state) {
+            const currentServices = await docker.listContainers({
+                filters: {
+                    label: [`hammerkit-id=${service.id()}`],
+                },
+            });
+            const currentService = currentServices[0];
+            if (!currentService) {
+                return;
+            }
+            const servicePid = 'hammerkit-pid' in currentService.Labels ? parseInt(currentService.Labels['hammerkit-pid']) : undefined;
+            const serviceState = 'hammerkit-state' in currentService.Labels ? currentService.Labels['hammerkit-state'] : '';
+            state.set({
+                type: 'running',
+                remote: { containerId: currentService.Id, pid: servicePid },
+                stateKey: serviceState,
+                dns: {
+                    containerId: currentService.Id,
+                },
+            });
+        },
+        async stop() {
+            const containers = await docker.listContainers({
+                all: true,
+                filters: {
+                    label: [`hammerkit-id=${service.id()}`],
+                },
+            });
+            for (const container of containers) {
+                await (0, remove_container_1.removeContainer)(docker.getContainer(container.Id));
+            }
+        },
+        async remove() {
+            await this.stop();
+            for (const volume of service.data.volumes) {
+                const volumeExists = await (0, get_docker_executor_1.existsVolume)(docker, volume.name);
+                if (!volumeExists) {
+                    continue;
+                }
+                await (0, get_docker_executor_1.removeVolume)(docker, service.status, volume.name);
+            }
+        },
+        async execute(environment, options) {
+            await (0, docker_service_1.dockerService)(docker, service, options, environment);
+        },
+        async restore(environment, path) {
+            await restoreContainer(docker, environment, service, path);
+        },
+        async archive(environment, path) {
+            await archiveContainer(docker, environment, service, path);
+        },
+        async currentStateKey() {
+            const containers = await docker.listContainers({
+                all: true,
+                filters: {
+                    label: [`hammerkit-id=${service.id()}`],
+                },
+            });
+            const container = containers[0];
+            if (!container) {
+                return null;
+            }
+            if (!container.Labels['hammerkit-state']) {
+                return null;
+            }
+            return container.Labels['hammerkit-state'];
+        },
+    };
+}
+exports.dockerServiceRuntime = dockerServiceRuntime;
+async function archiveContainer(docker, environment, item, path) {
+    await (0, using_container_1.usingContainer)(docker, item, {
+        abortSignal: environment.abortCtrl.signal,
+        Image: item.data.image,
+        Tty: true,
+        Entrypoint: ['sh'],
+        Cmd: ['-c', 'sleep 3600'],
+        WorkingDir: (0, execute_docker_1.convertToPosixPath)(item.data.cwd),
+        Labels: {
+            app: 'hammerkit',
+            'hammerkit-id': item.id(),
+            'hammerkit-pid': process.pid.toString(),
+            'hammerkit-type': 'task',
+        },
+        HostConfig: {
+            AutoRemove: true,
+            Binds: item.data.type === 'container-service'
+                ? item.data.volumes
+                    .filter((v) => !v.inherited)
+                    .map((v) => `${v.name}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`)
+                : item.data.generates
+                    .filter((v) => !v.inherited && !v.isFile)
+                    .map((v) => `${v.volumeName}:${(0, execute_docker_1.convertToPosixPath)(v.path)}`),
+        },
+    }, null, async (container) => {
+        for (const generatedArchive of (0, event_cache_1.getArchivePaths)(item.data, path)) {
+            const readable = await container.getArchive({
+                path: generatedArchive.path,
+            });
+            await environment.file.writeStream(generatedArchive.filename, readable);
+        }
+    });
+}
+//# sourceMappingURL=work-runtime-docker.js.map

package/dist/planner/work-runtime-kubernetes.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kubernetesForwardRuntime = exports.kubernetesServiceRuntime = exports.kubernetesTaskRuntime = void 0;
+const kubernetes_service_1 = require("../executer/kubernetes-service");
+const kubernetes_instance_1 = require("../kubernetes/kubernetes-instance");
+const replace_env_variables_1 = require("../environment/replace-env-variables");
+const apply_1 = require("../kubernetes/apply");
+const ensure_kubernetes_service_exists_1 = require("../kubernetes/ensure-kubernetes-service-exists");
+const ensure_kubernetes_deployment_exists_1 = require("../kubernetes/ensure-kubernetes-deployment-exists");
+const ensure_namespace_1 = require("../kubernetes/ensure-namespace");
+const ensure_persistent_data_1 = require("../kubernetes/ensure-persistent-data");
+const await_running_state_1 = require("../kubernetes/await-running-state");
+const volumes_1 = require("../kubernetes/volumes");
+const resources_1 = require("../kubernetes/resources");
+const ensure_ingress_1 = require("../kubernetes/ensure-ingress");
+const ensure_http_route_1 = require("../kubernetes/ensure-http-route");
+const find_process_1 = __importDefault(require("find-process"));
+const log_1 = require("../log");
+const version_1 = require("../version");
+const restore_kubernetes_data_1 = require("../kubernetes/restore-kubernetes-data");
+const store_kubernetes_data_1 = require("../kubernetes/store-kubernetes-data");
+const remove_persistent_data_1 = require("../kubernetes/remove-persistent-data");
+function statusCodeOf(e) {
+    const err = e;
+    return err?.statusCode ?? err?.response?.statusCode ?? err?.body?.code;
+}
+function kubernetesTaskRuntime(task, kubernetes) {
+    const instance = (0, kubernetes_instance_1.createKubernetesInstances)(kubernetes);
+    return {
+        initialize() {
+            return Promise.resolve();
+        },
+        async restore(environment, path) {
+            await (0, restore_kubernetes_data_1.restoreKubernetesData)(task, kubernetes, instance, environment, path);
+        },
+        async archive(environment, path) {
+            await (0, store_kubernetes_data_1.storeKubernetesData)(task, kubernetes, instance, environment, path);
+        },
+        async execute(environment, options) {
+            const envs = (0, replace_env_variables_1.getEnvironmentVariables)(task.data.envs);
+            const persistence = await (0, volumes_1.getKubernetesPersistence)(task);
+            await (0, ensure_namespace_1.ensureNamespace)(instance, kubernetes.namespace);
+            await (0, ensure_persistent_data_1.ensurePersistentData)(instance, kubernetes, environment, task, persistence);
+            const podName = `${task.name}-${options.stateKey}`;
+            let i = 0;
+            for (const cmd of task.data.cmds) {
+                const spec = {
+                    kind: 'Job',
+                    apiVersion: 'batch/v1',
+                    metadata: {
+                        namespace: kubernetes.namespace,
+                        name: podName,
+                        annotations: {
+                            'hammerkit.dev/version': (0, version_1.getVersion)(),
+                        },
+                        labels: {
+                            'hammerkit.dev/id': task.id(),
+                            'hammerkit.dev/state': options.stateKey,
+                        },
+                    },
+                    spec: {
+                        template: {
+                            metadata: {
+                                annotations: {
+                                    'hammerkit.dev/version': (0, version_1.getVersion)(),
+                                },
+                                labels: {
+                                    'hammerkit.dev/id': task.id(),
+                                    'hammerkit.dev/state': options.stateKey,
+                                },
+                            },
+                            spec: {
+                                containers: [
+                                    {
+                                        image: task.data.image,
+                                        command: [cmd.parsed.command],
+                                        args: cmd.parsed.args,
+                                        workingDir: cmd.cwd,
+                                        env: Object.entries(envs).map(([key, value]) => ({ name: key, value })),
+                                        name: `cmd-${++i}`,
+                                        volumeMounts: persistence.mounts.map((m) => m.mount),
+                                    },
+                                ],
+                                volumes: persistence.volumes,
+                                restartPolicy: 'Never',
+                            },
+                        },
+                        backoffLimit: 1,
+                        parallelism: 1,
+                    },
+                };
+                try {
+                    const pod = await (0, apply_1.apply)(instance, spec);
+                    if (!pod.status?.succeeded) {
+                        await (0, await_running_state_1.awaitJobState)(instance, kubernetes, spec.metadata.name);
+                    }
+                    task.status.write('debug', 'pod completed');
+                    await instance.batchApi.deleteNamespacedJob(podName, kubernetes.namespace);
+                }
+                catch (e) {
+                    options.state.set({
+                        stateKey: options.stateKey,
+                        type: 'error',
+                        errorMessage: (0, log_1.getErrorMessage)(e),
+                    });
+                    return;
+                }
+            }
+        },
+        async stop() {
+            const jobs = await instance.batchApi.listNamespacedJob(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
+            for (const pod of jobs.body.items) {
+                if (pod.metadata?.name) {
+                    await instance.batchApi.deleteNamespacedJob(pod.metadata.name, kubernetes.namespace);
+                }
+            }
+            const deployments = await instance.appsApi.listNamespacedDeployment(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
+            for (const deploy of deployments.body.items) {
+                if (deploy.metadata?.name) {
+                    await instance.appsApi.deleteNamespacedDeployment(deploy.metadata.name, kubernetes.namespace);
+                }
+            }
+            const pods = await instance.coreApi.listNamespacedPod(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
+            for (const pod of pods.body.items) {
+                if (pod.metadata?.name) {
+                    await instance.coreApi.deleteNamespacedPod(pod.metadata.name, kubernetes.namespace);
+                }
+            }
+        },
+        async remove() {
+            await this.stop();
+            await (0, remove_persistent_data_1.removePersistentData)(instance, kubernetes, task);
+        },
+        async currentStateKey() {
+            const jobs = await instance.batchApi.listNamespacedJob(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
+            const completedStates = jobs.body.items
+                .filter((j) => j.status?.succeeded && j.metadata?.labels?.['hammerkit.dev/state'])
+                .map((j) => j.metadata.labels['hammerkit.dev/state']);
+            return completedStates[completedStates.length - 1] ?? null;
+        },
+    };
+}
+exports.kubernetesTaskRuntime = kubernetesTaskRuntime;
+function kubernetesServiceRuntime(service, kubernetes) {
+    const instance = (0, kubernetes_instance_1.createKubernetesInstances)(kubernetes);
+    return {
+        initialize() {
+            return Promise.resolve();
+        },
+        async restore(environment, path) {
+            await (0, restore_kubernetes_data_1.restoreKubernetesData)(service, kubernetes, instance, environment, path);
+        },
+        async archive(environment, path) {
+            await (0, store_kubernetes_data_1.storeKubernetesData)(service, kubernetes, instance, environment, path);
+        },
+        async stop() {
+            const deployments = await instance.appsApi.listNamespacedDeployment(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
+            for (const deployment of deployments.body.items) {
+                if (deployment.metadata?.name) {
+                    await instance.appsApi.deleteNamespacedDeployment(deployment.metadata.name, kubernetes.namespace);
+                }
+            }
+        },
+        async execute(environment, options) {
+            const persistence = await (0, volumes_1.getKubernetesPersistence)(service);
+            await (0, ensure_namespace_1.ensureNamespace)(instance, kubernetes.namespace);
+            await (0, ensure_kubernetes_service_exists_1.ensureKubernetesServiceExists)(instance, kubernetes, service);
+            await (0, ensure_persistent_data_1.ensurePersistentData)(instance, kubernetes, environment, service, persistence);
+            await (0, ensure_kubernetes_deployment_exists_1.ensureKubernetesDeploymentExists)(instance, kubernetes, service, persistence, options.stateKey);
+            const name = (0, resources_1.getResourceName)(service);
+            options.state.set({
+                type: 'running',
+                dns: { containerId: name },
+                stateKey: options.stateKey,
+                remote: null,
+            });
+            const ingresses = kubernetes.ingresses.filter((i) => i.service === service.name);
+            for (const ingress of ingresses) {
+                if (ingress.kind === 'httproute') {
+                    await (0, ensure_http_route_1.ensureHttpRoute)(instance, kubernetes, ingress, service);
+                }
+                else {
+                    await (0, ensure_ingress_1.ensureIngress)(instance, kubernetes, ingress, service);
+                }
+            }
+        },
+        async remove() {
+            const ingresses = await instance.networkingApi.listNamespacedIngress(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
+            for (const ingress of ingresses.body.items) {
+                if (ingress.metadata?.name) {
+                    await instance.networkingApi.deleteNamespacedIngress(ingress.metadata.name, kubernetes.namespace);
+                }
+            }
+            // HTTPRoutes are a CRD, so they are deleted by name through the generic
+            // objectApi rather than listed (a list would error on clusters without the
+            // Gateway API CRDs even when none are declared). Only entries this service
+            // declared as httproute are removed; a missing route (404) is fine.
+            const httpRoutes = kubernetes.ingresses.filter((i) => i.kind === 'httproute' && i.service === service.name);
+            for (const route of httpRoutes) {
+                try {
+                    await instance.objectApi.delete({
+                        apiVersion: ensure_http_route_1.HTTP_ROUTE_API_VERSION,
+                        kind: ensure_http_route_1.HTTP_ROUTE_KIND,
+                        metadata: { name: route.host, namespace: kubernetes.namespace },
+                    });
+                }
+                catch (e) {
+                    if (statusCodeOf(e) !== 404) {
+                        throw e;
+                    }
+                }
+            }
+            const services = await instance.coreApi.listNamespacedService(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
+            for (const service of services.body.items) {
+                if (service.metadata?.name) {
+                    await instance.coreApi.deleteNamespacedService(service.metadata.name, kubernetes.namespace);
+                }
+            }
+            await this.stop();
+            await (0, remove_persistent_data_1.removePersistentData)(instance, kubernetes, service);
+        },
+        async currentStateKey() {
+            const deployments = await instance.appsApi.listNamespacedDeployment(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${service.id()}`);
+            const deployment = deployments.body.items[0];
+            return deployment?.metadata?.labels?.['hammerkit.dev/state'] ?? null;
+        },
+    };
+}
+exports.kubernetesServiceRuntime = kubernetesServiceRuntime;
+function kubernetesForwardRuntime(service) {
+    return {
+        async initialize(item) {
+            for (const port of service.data.ports) {
+                if (port.hostPort === null) {
+                    continue;
+                }
+                const processes = await (0, find_process_1.default)('port', port.hostPort);
+                if (!processes || processes.length === 0) {
+                    continue;
+                }
+                item.set({
+                    type: 'error',
+                    errorMessage: `Host port ${port.hostPort} already in use`,
+                    stateKey: null,
+                });
+            }
+        },
+        async restore() { },
+        async archive() { },
+        async remove() { },
+        async execute(_environment, options) {
+            await (0, kubernetes_service_1.kubernetesService)(service, options);
+        },
+        currentStateKey() {
+            return Promise.resolve(null);
+        },
+        async stop() { },
+    };
+}
+exports.kubernetesForwardRuntime = kubernetesForwardRuntime;
+//# sourceMappingURL=work-runtime-kubernetes.js.map