hammerkit 1.7.0 → 1.9.0

package/dist/kubernetes/resolve-pod-name.js

@@ -7,9 +7,9 @@ function formatSelector(matchLabels) {
         .join(',');
 }
 async function findReadyPod(coreApi, namespace, labelSelector) {
-    const pods = await coreApi.listNamespacedPod(namespace, undefined, undefined, undefined, undefined, labelSelector);
-    const ready = pods.body.items.find((p) => p.status?.conditions?.some((c) => c.type === 'Ready' && c.status === 'True'));
-    const pod = ready ?? pods.body.items[0];
+    const pods = await coreApi.listNamespacedPod({ namespace, labelSelector });
+    const ready = pods.items.find((p) => p.status?.conditions?.some((c) => c.type === 'Ready' && c.status === 'True'));
+    const pod = ready ?? pods.items[0];
     if (!pod?.metadata?.name) {
         throw new Error(`no pod found for selector ${labelSelector} in namespace ${namespace}`);
     }
@@ -21,16 +21,16 @@ async function resolvePodName(coreApi, appsApi, namespace, selector) {
         return selector.name;
     }
     if (type === 'service') {
-        const svc = await coreApi.readNamespacedService(selector.name, namespace);
-        const matchLabels = svc.body.spec?.selector;
+        const svc = await coreApi.readNamespacedService({ name: selector.name, namespace });
+        const matchLabels = svc.spec?.selector;
         if (!matchLabels || Object.keys(matchLabels).length === 0) {
             throw new Error(`service ${selector.name} has no selector`);
         }
         return findReadyPod(coreApi, namespace, formatSelector(matchLabels));
     }
     if (type === 'deployment') {
-        const deploy = await appsApi.readNamespacedDeployment(selector.name, namespace);
-        const matchLabels = deploy.body.spec?.selector?.matchLabels;
+        const deploy = await appsApi.readNamespacedDeployment({ name: selector.name, namespace });
+        const matchLabels = deploy.spec?.selector?.matchLabels;
         if (!matchLabels) {
             throw new Error(`deployment ${selector.name} has no matchLabels`);
         }

package/dist/planner/unreferenced-build-file-envs.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnreferencedBuildFileEnvs = void 0;
+// Build-file `envs` are passed to every task of the file and are part of every
+// task's cache key, so a value only some tasks use (an image tag, a test token)
+// reruns all of them when it changes. Returns the build-file envs the task's own
+// definition never mentions as `$NAME` / `${NAME}`. The task may still read
+// them implicitly at runtime (NODE_ENV), so this is only worth a warning.
+function getUnreferencedBuildFileEnvs(task) {
+    const buildFileEnvs = task.scope.schema.envs ?? {};
+    const taskSchema = getTaskSchema(task);
+    // an aggregate (deps only) runs nothing, so a rerun costs nothing
+    if (!taskSchema || 'extend' in taskSchema || (taskSchema.cmds ?? []).length === 0) {
+        return [];
+    }
+    const taskEnvs = taskSchema.envs ?? {};
+    const definition = JSON.stringify(taskSchema);
+    return Object.keys(buildFileEnvs)
+        .filter((name) => !(name in taskEnvs))
+        .filter((name) => !isReferenced(definition, name));
+}
+exports.getUnreferencedBuildFileEnvs = getUnreferencedBuildFileEnvs;
+function getTaskSchema(task) {
+    const prefix = task.scope.namePrefix.length > 0 ? `${task.scope.namePrefix}:` : '';
+    if (!task.name.startsWith(prefix)) {
+        return null;
+    }
+    const tasks = task.scope.schema.tasks ?? {};
+    return tasks[task.name.substring(prefix.length)] ?? null;
+}
+function isReferenced(definition, name) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`\\$(\\{${escaped}\\}|${escaped}(?![A-Za-z0-9_]))`, 'i').test(definition);
+}
+//# sourceMappingURL=unreferenced-build-file-envs.js.map

package/dist/planner/utils/append-work-environment.js

@@ -13,7 +13,7 @@ function appendWorkEnvironment(referenced) {
             type: 'kubernetes',
             context: referenced.schema.kubernetes.context,
             kubeConfig: referenced.schema.kubernetes.kubeconfig,
-            ingresses: referenced.schema.kubernetes.ingresses || [],
+            httpRoutes: referenced.schema.kubernetes.httpRoutes || [],
             namespace: referenced.schema.kubernetes.namespace ?? 'default',
         };
     }

package/dist/planner/utils/append-work-service.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.appendWorkService = void 0;
+exports.getHealthcheckTimeout = exports.DEFAULT_HEALTHCHECK_TIMEOUT = exports.appendWorkService = void 0;
 const work_service_id_1 = require("../work-service-id");
 const parse_work_ports_1 = require("./parse-work-ports");
 const template_value_1 = require("./template-value");
@@ -17,6 +17,8 @@ const state_1 = require("../../executer/state");
 const lazy_resolver_1 = require("../../executer/lazy-resolver");
 const get_work_runtime_1 = require("./get-work-runtime");
 const resolve_cache_1 = require("../../cache/resolve-cache");
+const units_1 = require("../../utils/units");
+const log_1 = require("../../log");
 function appendWorkService(workTree, service, environment, context) {
     const workService = parseService(workTree, service, environment, context);
     if (!workTree.services[workService.name]) {
@@ -91,13 +93,16 @@ function parseService(workTree, service, environment, context) {
             continuous: service.schema.continuous ?? false,
             healthcheck: service.schema.healthcheck
                 ? {
-                    cmd: (0, parse_work_command_1.parseWorkCommand)(service.cwd, service.schema.healthcheck, envs),
+                    cmd: (0, parse_work_command_1.parseWorkCommand)(service.cwd, service.schema.healthcheck.cmd, envs),
+                    timeout: getHealthcheckTimeout(service.schema.healthcheck.timeout, environment),
                 }
                 : null,
             envs: (0, replace_env_variables_1.buildEnvironmentVariables)(service.envs, environment, context),
             image: (0, template_value_1.templateValue)(service.schema.image, envs),
             cwd: service.cwd,
             cmd: service.schema.cmd ? (0, parse_work_command_1.parseWorkCommand)(service.cwd, service.schema.cmd, envs) : null,
+            workdir: service.schema.workdir ? (0, template_value_1.templateValue)(service.schema.workdir, envs) : null,
+            shell: service.schema.shell ? (0, template_value_1.templateValue)(service.schema.shell, envs) : null,
             volumes: (0, parse_work_volume_1.parseWorkVolumes)(service.cwd, service.schema.volumes, envs),
             mounts: (0, parse_work_mounts_1.parseWorkMounts)(service.cwd, service.schema, envs),
             src: (0, parse_work_source_1.parseWorkSource)(service.cwd, service.schema.src, envs),
@@ -105,4 +110,23 @@ function parseService(workTree, service, environment, context) {
         };
     }
 }
+exports.DEFAULT_HEALTHCHECK_TIMEOUT = '20s';
+// A service's own `healthcheck.timeout`, else HAMMERKIT_HEALTHCHECK_TIMEOUT,
+// else 20s: a check that never passes fails the run instead of hanging it.
+function getHealthcheckTimeout(timeout, environment) {
+    if (timeout) {
+        return (0, units_1.parseDuration)(timeout);
+    }
+    const fromEnv = environment.processEnvs['HAMMERKIT_HEALTHCHECK_TIMEOUT'];
+    if (fromEnv) {
+        try {
+            return (0, units_1.parseDuration)(fromEnv);
+        }
+        catch (e) {
+            throw new Error(`HAMMERKIT_HEALTHCHECK_TIMEOUT: ${(0, log_1.getErrorMessage)(e)}`);
+        }
+    }
+    return (0, units_1.parseDuration)(exports.DEFAULT_HEALTHCHECK_TIMEOUT);
+}
+exports.getHealthcheckTimeout = getHealthcheckTimeout;
 //# sourceMappingURL=append-work-service.js.map

package/dist/planner/utils/get-outputs-to-reset.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOutputsToReset = void 0;
+const path_1 = require("path");
+function contains(parent, path) {
+    const rel = (0, path_1.relative)(parent, path);
+    return rel === '' || (!rel.startsWith('..') && !(0, path_1.isAbsolute)(rel));
+}
+// The outputs a run empties before the task's commands: its own outputs with
+// resetOnChange (the default), except one that is a source or contains one
+// (`package-lock.json` declared both ways) or contains the task's directory.
+// Emptying those would delete what the task reads.
+function getOutputsToReset(task) {
+    return task.generates.filter((generate) => generate.resetOnChange &&
+        !generate.inherited &&
+        !contains(generate.path, task.cwd) &&
+        !task.src.some((src) => contains(generate.path, src.absolutePath)));
+}
+exports.getOutputsToReset = getOutputsToReset;
+//# sourceMappingURL=get-outputs-to-reset.js.map

package/dist/planner/utils/parse-work-generate.js

@@ -24,12 +24,12 @@ function parseWorkGenerate(cwd, schema, envs) {
 exports.parseWorkGenerate = parseWorkGenerate;
 function mapGenerate(generate) {
     if (typeof generate === 'string') {
-        return { path: generate, resetOnChange: false, export: false };
+        return { path: generate, resetOnChange: true, export: false };
     }
     else {
         return {
             path: generate.path,
-            resetOnChange: generate.resetOnChange ?? false,
+            resetOnChange: generate.resetOnChange ?? true,
             export: generate.export ?? false,
         };
     }

package/dist/planner/validate.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkIfContextExists = exports.hasDependencyCycle = exports.hasNeedCycle = exports.hasMixedCycle = exports.validate = void 0;
 const read_build_file_1 = require("../parser/read-build-file");
 const plan_work_tasks_1 = require("./utils/plan-work-tasks");
+const unreferenced_build_file_envs_1 = require("./unreferenced-build-file-envs");
 async function* validate(workTree, context) {
     const cycleItems = [];
     for (const item of (0, plan_work_tasks_1.iterateWorkServices)(workTree)) {
@@ -49,6 +50,15 @@ async function* validate(workTree, context) {
         if ((!task.cmds || task.cmds.length === 0) && (!item.deps || item.deps.length === 0)) {
             yield { type: 'warn', message: `task is empty`, item: task };
         }
+        const unreferencedEnvs = (0, unreferenced_build_file_envs_1.getUnreferencedBuildFileEnvs)(task);
+        if (unreferencedEnvs.length > 0) {
+            yield {
+                type: 'warn',
+                message: `build-file envs ${unreferencedEnvs.join(', ')} are part of this task's cache key but not referenced ` +
+                    `by it: changing them reruns it. If it doesn't read them at runtime, define them on the tasks that do`,
+                item: task,
+            };
+        }
         for (const src of task.src) {
             if (!(await context.file.exists(src.absolutePath))) {
                 yield {

package/dist/planner/work-healthcheck.js

@@ -1,3 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHealthcheckTimeoutMessage = void 0;
+const units_1 = require("../utils/units");
+function getHealthcheckTimeoutMessage(serviceName, healthcheck) {
+    return (`service ${serviceName} did not pass its healthcheck "${healthcheck.cmd.cmd}" within ` +
+        `${(0, units_1.formatDuration)(healthcheck.timeout)} of starting (see its log above; raise healthcheck.timeout ` +
+        `or HAMMERKIT_HEALTHCHECK_TIMEOUT if it is just slow)`);
+}
+exports.getHealthcheckTimeoutMessage = getHealthcheckTimeoutMessage;
 //# sourceMappingURL=work-healthcheck.js.map

package/dist/planner/work-instance-id.js

@@ -4,9 +4,9 @@ exports.getWorkInstanceId = void 0;
 const crypto_1 = require("crypto");
 // `id()` is the portable cache identity: identical for the same task in every
 // checkout, so a shared cache hits across machines. Machine-local runtime state
-// (docker container labels, the cache staging directory) must instead stay
-// scoped to one checkout — two worktrees of the same repo on one host would
-// otherwise see each other's paused containers and staging files. The instance
+// (docker container labels, task state files, the cache staging directory)
+// must instead stay scoped to one checkout — two worktrees of the same repo on
+// one host would otherwise see each other's state records and staging files. The instance
 // id folds the absolute project root into the portable id for that purpose.
 function getWorkInstanceId(item) {
     return (0, crypto_1.createHash)('sha1').update(`${item.id()}\0${item.data.projectRoot}`).digest('hex');

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dockerServiceRuntime = exports.dockerTaskRuntime = void 0;
+const run_labels_1 = require("../docker/run-labels");
 const execute_docker_1 = require("../executer/execute-docker");
 const remove_container_1 = require("../docker/remove-container");
 const docker_task_1 = require("../executer/docker-task");
@@ -12,6 +13,8 @@ const path_1 = require("path");
 const tar_1 = require("tar");
 const plan_work_volume_1 = require("./utils/plan-work-volume");
 const work_instance_id_1 = require("./work-instance-id");
+const stream_1 = require("stream");
+const container_task_state_1 = require("../executer/container-task-state");
 function dockerTaskRuntime(task, workEnvironment) {
     const docker = (0, execute_docker_1.getContainerCli)(workEnvironment);
     return {
@@ -21,7 +24,8 @@ function dockerTaskRuntime(task, workEnvironment) {
                     label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(task)}`],
                 },
             });
-            const currentTask = currentTasks[0];
+            // a paused container is a state record of hammerkit before 1.9, not a run
+            const currentTask = currentTasks.find((c) => c.State === 'running');
             if (!currentTask) {
                 return;
             }
@@ -52,8 +56,9 @@ function dockerTaskRuntime(task, workEnvironment) {
         async execute(environment, options) {
             await (0, docker_task_1.dockerTask)(docker, task, environment, options);
         },
-        async remove() {
+        async remove(environment) {
             await this.stop();
+            await (0, container_task_state_1.removeContainerTaskState)(environment, task);
             for (const generate of task.data.generates) {
                 if (generate.inherited) {
                     continue;
@@ -69,17 +74,8 @@ function dockerTaskRuntime(task, workEnvironment) {
             }
         },
         async currentStateKey(environment) {
-            const containers = await docker.listContainers({
-                all: true,
-                filters: {
-                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(task)}`],
-                },
-            });
-            const container = containers[0];
-            if (!container) {
-                return null;
-            }
-            if (!container.Labels['hammerkit-state']) {
+            const stateKey = await (0, container_task_state_1.readContainerTaskState)(environment, task);
+            if (!stateKey) {
                 return null;
             }
             // outputs removed since the run (a deleted export, a pruned volume)
@@ -92,7 +88,7 @@ function dockerTaskRuntime(task, workEnvironment) {
                     return null;
                 }
             }
-            return container.Labels['hammerkit-state'];
+            return stateKey;
         },
     };
 }
@@ -113,7 +109,7 @@ async function restoreContainer(docker, environment, item, path) {
         Labels: {
             app: 'hammerkit',
             'hammerkit-id': (0, work_instance_id_1.getWorkInstanceId)(item),
-            'hammerkit-pid': process.pid.toString(),
+            ...(0, run_labels_1.getRunLabels)(),
             'hammerkit-type': 'task',
         },
         HostConfig: {
@@ -129,9 +125,12 @@ async function restoreContainer(docker, environment, item, path) {
                     .filter((v) => !v.inherited && !v.isFile)
                     .map((v) => `${v.volumeName}:${(0, execute_docker_1.convertToPosixPath)(v.path)}`),
         },
-    }, null, async (container) => {
+    }, async (container) => {
         for (const generate of (0, event_cache_1.getArchivePaths)(item.data, path)) {
             if (await environment.file.exists(generate.filename)) {
+                // a cache hit means exactly the stored outputs: whatever a failed or
+                // older run left in the volume goes first
+                await (0, execute_docker_1.clearContainerDirectory)(item.status, environment, container, generate.path);
                 await container.putArchive(environment.file.readStream(generate.filename), {
                     path: (0, path_1.dirname)(generate.path),
                 });
@@ -142,6 +141,7 @@ async function restoreContainer(docker, environment, item, path) {
         const onHost = new Set(item.data.generates.filter((g) => !g.inherited && isOnHost(g)).map((g) => g.path));
         for (const generate of (0, event_cache_1.getArchivePaths)(item.data, path)) {
             if (onHost.has(generate.path) && (await environment.file.exists(generate.filename))) {
+                await environment.file.remove(generate.path);
                 await (0, tar_1.extract)({ file: generate.filename, cwd: (0, path_1.dirname)(generate.path) });
             }
         }
@@ -231,7 +231,7 @@ async function archiveContainer(docker, environment, item, path) {
         Labels: {
             app: 'hammerkit',
             'hammerkit-id': (0, work_instance_id_1.getWorkInstanceId)(item),
-            'hammerkit-pid': process.pid.toString(),
+            ...(0, run_labels_1.getRunLabels)(),
             'hammerkit-type': 'task',
         },
         HostConfig: {
@@ -244,14 +244,14 @@ async function archiveContainer(docker, environment, item, path) {
                     .filter((v) => !v.inherited && !v.isFile)
                     .map((v) => `${v.volumeName}:${(0, execute_docker_1.convertToPosixPath)(v.path)}`),
         },
-    }, null, async (container) => {
+    }, async (container) => {
         const hostFiles = new Set(item.data.type === 'container-task'
             ? item.data.generates.filter((g) => !g.inherited && g.isFile).map((g) => g.path)
             : []);
         for (const generatedArchive of (0, event_cache_1.getArchivePaths)(item.data, path)) {
             // a file output is a bind mount of a host file, so archive it from the host
             const readable = hostFiles.has(generatedArchive.path)
-                ? (0, tar_1.create)({ cwd: (0, path_1.dirname)(generatedArchive.path) }, [(0, path_1.basename)(generatedArchive.path)])
+                ? stream_1.Readable.from((0, tar_1.create)({ cwd: (0, path_1.dirname)(generatedArchive.path) }, [(0, path_1.basename)(generatedArchive.path)]))
                 : await container.getArchive({
                     path: generatedArchive.path,
                 });

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

@@ -16,7 +16,6 @@ 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");
@@ -24,13 +23,12 @@ 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;
-}
 async function listJobNames(instance, kubernetes, task) {
-    const jobs = await instance.batchApi.listNamespacedJob(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-    return jobs.body.items.flatMap((job) => (job.metadata?.name ? [job.metadata.name] : []));
+    const jobs = await instance.batchApi.listNamespacedJob({
+        namespace: kubernetes.namespace,
+        labelSelector: `hammerkit.dev/id=${task.id()}`,
+    });
+    return jobs.items.flatMap((job) => (job.metadata?.name ? [job.metadata.name] : []));
 }
 function kubernetesTaskRuntime(task, kubernetes) {
     const instance = (0, kubernetes_instance_1.createKubernetesInstances)(kubernetes);
@@ -128,22 +126,34 @@ function kubernetesTaskRuntime(task, kubernetes) {
             }
         },
         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) {
+            const jobs = await instance.batchApi.listNamespacedJob({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            for (const pod of jobs.items) {
                 if (pod.metadata?.name) {
-                    await instance.batchApi.deleteNamespacedJob(pod.metadata.name, kubernetes.namespace);
+                    await instance.batchApi.deleteNamespacedJob({ name: pod.metadata.name, namespace: 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) {
+            const deployments = await instance.appsApi.listNamespacedDeployment({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            for (const deploy of deployments.items) {
                 if (deploy.metadata?.name) {
-                    await instance.appsApi.deleteNamespacedDeployment(deploy.metadata.name, kubernetes.namespace);
+                    await instance.appsApi.deleteNamespacedDeployment({
+                        name: deploy.metadata.name,
+                        namespace: 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) {
+            const pods = await instance.coreApi.listNamespacedPod({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            for (const pod of pods.items) {
                 if (pod.metadata?.name) {
-                    await instance.coreApi.deleteNamespacedPod(pod.metadata.name, kubernetes.namespace);
+                    await instance.coreApi.deleteNamespacedPod({ name: pod.metadata.name, namespace: kubernetes.namespace });
                 }
             }
         },
@@ -152,8 +162,11 @@ function kubernetesTaskRuntime(task, kubernetes) {
             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
+            const jobs = await instance.batchApi.listNamespacedJob({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${task.id()}`,
+            });
+            const completedStates = jobs.items
                 .filter((j) => j.status?.succeeded && j.metadata?.labels?.['hammerkit.dev/state'])
                 .map((j) => j.metadata.labels['hammerkit.dev/state']);
             const stateKey = completedStates[completedStates.length - 1] ?? null;
@@ -163,11 +176,14 @@ function kubernetesTaskRuntime(task, kubernetes) {
             // outputs live in the task's claim; without it the finished job left
             // nothing to reuse
             try {
-                const claim = await instance.coreApi.readNamespacedPersistentVolumeClaim((0, volumes_1.getVolumeName)(task), kubernetes.namespace);
-                return claim.body.metadata?.deletionTimestamp ? null : stateKey;
+                const claim = await instance.coreApi.readNamespacedPersistentVolumeClaim({
+                    name: (0, volumes_1.getVolumeName)(task),
+                    namespace: kubernetes.namespace,
+                });
+                return claim.metadata?.deletionTimestamp ? null : stateKey;
             }
             catch (e) {
-                if (statusCodeOf(e) === 404) {
+                if ((0, apply_1.statusCodeOf)(e) === 404) {
                     return null;
                 }
                 throw e;
@@ -189,10 +205,16 @@ function kubernetesServiceRuntime(service, kubernetes) {
             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) {
+            const deployments = await instance.appsApi.listNamespacedDeployment({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${service.id()}`,
+            });
+            for (const deployment of deployments.items) {
                 if (deployment.metadata?.name) {
-                    await instance.appsApi.deleteNamespacedDeployment(deployment.metadata.name, kubernetes.namespace);
+                    await instance.appsApi.deleteNamespacedDeployment({
+                        name: deployment.metadata.name,
+                        namespace: kubernetes.namespace,
+                    });
                 }
             }
         },
@@ -209,29 +231,16 @@ function kubernetesServiceRuntime(service, kubernetes) {
                 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);
-                }
+            for (const route of kubernetes.httpRoutes.filter((r) => r.service === service.name)) {
+                await (0, ensure_http_route_1.ensureHttpRoute)(instance, kubernetes, route, 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) {
+            // Gateway API CRDs even when none are declared). Only the routes this
+            // service declares are removed; a missing route (404) is fine.
+            for (const route of kubernetes.httpRoutes.filter((r) => r.service === service.name)) {
                 try {
                     await instance.objectApi.delete({
                         apiVersion: ensure_http_route_1.HTTP_ROUTE_API_VERSION,
@@ -240,23 +249,32 @@ function kubernetesServiceRuntime(service, kubernetes) {
                     });
                 }
                 catch (e) {
-                    if (statusCodeOf(e) !== 404) {
+                    if ((0, apply_1.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) {
+            const services = await instance.coreApi.listNamespacedService({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${service.id()}`,
+            });
+            for (const service of services.items) {
                 if (service.metadata?.name) {
-                    await instance.coreApi.deleteNamespacedService(service.metadata.name, kubernetes.namespace);
+                    await instance.coreApi.deleteNamespacedService({
+                        name: service.metadata.name,
+                        namespace: 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];
+            const deployments = await instance.appsApi.listNamespacedDeployment({
+                namespace: kubernetes.namespace,
+                labelSelector: `hammerkit.dev/id=${service.id()}`,
+            });
+            const deployment = deployments.items[0];
             return deployment?.metadata?.labels?.['hammerkit.dev/state'] ?? null;
         },
     };

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

@@ -8,7 +8,9 @@ const tar_1 = require("tar");
 const path_1 = require("path");
 const local_task_1 = require("../executer/local-task");
 const event_cache_1 = require("../executer/event-cache");
+const get_outputs_to_reset_1 = require("./utils/get-outputs-to-reset");
 const find_process_1 = __importDefault(require("find-process"));
+const stream_1 = require("stream");
 function getStateFilename(task) {
     return (0, path_1.join)(task.data.cwd, '.hammerkit', `${task.id()}`);
 }
@@ -56,8 +58,21 @@ function getLocalWorkRuntime(task) {
             const pidFile = getPidFilename(task);
             await environment.file.writeFile(pidFile, `${process.pid}`);
             try {
+                // The record says "the outputs belong to this state key". A run that
+                // fails overwrites outputs, so the previous record goes first, and only
+                // a run that succeeded writes a new one.
+                const stateFile = getStateFilename(task);
+                if (await environment.file.exists(stateFile)) {
+                    await environment.file.remove(stateFile);
+                }
+                for (const generate of (0, get_outputs_to_reset_1.getOutputsToReset)(task.data)) {
+                    await environment.file.remove(generate.path);
+                }
                 await (0, local_task_1.localTask)(task, environment, options);
-                await environment.file.writeFile(getStateFilename(task), options.stateKey);
+                const failed = ['crash', 'error', 'canceled'].includes(options.state.current.type);
+                if (!failed) {
+                    await environment.file.writeFile(stateFile, options.stateKey);
+                }
             }
             finally {
                 if (await environment.file.exists(pidFile)) {
@@ -96,15 +111,17 @@ function getLocalWorkRuntime(task) {
 exports.getLocalWorkRuntime = getLocalWorkRuntime;
 async function archiveLocal(environment, task, path) {
     for (const generatedArchive of (0, event_cache_1.getArchivePaths)(task.data, path)) {
-        await environment.file.writeStream(generatedArchive.filename, (0, tar_1.create)({
-            cwd: task.data.cwd,
-            gzip: true,
-        }, [(0, path_1.relative)(task.data.cwd, generatedArchive.path)]));
+        await environment.file.writeStream(generatedArchive.filename, 
+        // tar's stream is a Minipass stream; Readable.from adapts it to a Node one
+        stream_1.Readable.from((0, tar_1.create)({ cwd: task.data.cwd, gzip: true }, [(0, path_1.relative)(task.data.cwd, generatedArchive.path)])));
     }
 }
 async function restoreLocal(environment, task, path) {
     for (const generate of (0, event_cache_1.getArchivePaths)(task, path)) {
         if (await environment.file.exists(generate.filename)) {
+            // a cache hit means exactly the stored outputs: whatever a failed or
+            // older run left in the folder goes first
+            await environment.file.remove(generate.path);
             await (0, tar_1.extract)({
                 file: generate.filename,
                 cwd: task.cwd,

package/dist/planner/work-service-id.js

@@ -23,6 +23,9 @@ function getWorkServiceId(service) {
                 .sort(),
             src: service.src.map((s) => portable(s.absolutePath)).sort(),
             mounts: service.mounts.map((m) => m.mount).sort(),
+            // only when declared, so existing services keep their ids
+            ...(service.workdir ? { workdir: service.workdir } : {}),
+            ...(service.shell ? { shell: service.shell } : {}),
         }
         : {
             context: service.context,