hammerkit 1.7.0 → 1.9.0

package/dist/executer/execute-work-task.js

@@ -51,6 +51,15 @@ function withDeadline(parent, timeout) {
         },
     };
 }
+// A task without cmds only groups its dependencies (`ci: { deps: [test, build] }`).
+// Having no src of its own it is never a cache hit, so its dependencies are
+// always checked and their outputs restored. When every one of them was a hit,
+// nothing ran: report the group as cached too. Reporting only, the cache
+// decision is untouched.
+function onlyGroupsCacheHits(work) {
+    return (work.data.cmds.length === 0 &&
+        work.deps.every((dep) => dep.state.current.type === 'completed' && dep.state.current.cached));
+}
 async function executeWorkTask(work, environment, options, 
 // when set, the task was not requested and only runs if one of these tasks
 // depending on it misses the cache (see executeWorkTree)
@@ -139,12 +148,13 @@ dependents = null) {
                 if (work.state.current.type === 'running') {
                     work.status.write('debug', 'completed for state key ' + cacheState.stateKey);
                     await pushToBackend(work, environment, cacheState, options);
+                    const cached = onlyGroupsCacheHits(work);
                     work.state.set({
                         stateKey: cacheState.stateKey,
                         type: 'completed',
-                        cached: false,
+                        cached,
                         duration: (0, states_1.getDuration)(started),
-                        missCauses,
+                        missCauses: cached ? undefined : missCauses,
                     });
                 }
                 else {
@@ -170,6 +180,11 @@ dependents = null) {
                 errorMessage: (0, log_1.getErrorMessage)(e),
                 stateKey: null,
             });
+            // Stop the run like a failing command does: dependents wait for this task
+            // to complete, which it now never will.
+            if (!options.watch) {
+                environment.abortCtrl.abort();
+            }
         }
     }
 }

package/dist/executer/execution-steps.js

@@ -26,18 +26,13 @@ async function prepareVolume(item, docker) {
         }
     }
     if ((0, work_task_1.isContainerWorkTask)(item.data)) {
+        // a task's outputs are emptied inside its container (see dockerTask)
         for (const generate of item.data.generates) {
             if (generate.isFile) {
                 continue;
             }
-            if (generate.resetOnChange && !generate.inherited) {
-                item.status.write('debug', 'recreate volume');
-                await (0, get_docker_executor_1.recreateVolume)(docker, item.status, generate.volumeName);
-            }
-            else {
-                item.status.write('debug', 'ensure volume exists');
-                await (0, get_docker_executor_1.ensureVolumeExists)(docker, item.status, generate.volumeName);
-            }
+            item.status.write('debug', 'ensure volume exists');
+            await (0, get_docker_executor_1.ensureVolumeExists)(docker, item.status, generate.volumeName);
         }
     }
 }

package/dist/executer/get-container-binds.js

@@ -1,10 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getContainerBinds = void 0;
+const path_1 = require("path");
+function isInside(path, parent) {
+    const rel = (0, path_1.relative)(parent, path);
+    return rel !== '' && !rel.startsWith('..') && !(0, path_1.isAbsolute)(rel);
+}
 function getContainerBinds(item) {
+    const sources = item.data.src.map((s) => s.absolutePath);
     const items = [
         ...item.data.mounts,
-        ...item.data.src.map((s) => ({ localPath: s.absolutePath, containerPath: s.absolutePath })),
+        // A source inside another source (a dependency's `app/app.csproj` under the
+        // task's own `app`) is already visible through the outer bind. Binding it
+        // again would nest bind mounts, which Docker Desktop then refuses to let the
+        // host delete while the container exists.
+        ...sources
+            .filter((path) => !sources.some((other) => isInside(path, other)))
+            .map((path) => ({ localPath: path, containerPath: path })),
         ...item.data.generates.filter((g) => !g.isFile).map((v) => ({ localPath: v.volumeName, containerPath: v.path })),
         ...item.data.generates.filter((g) => g.isFile).map((v) => ({ localPath: v.path, containerPath: v.path })),
     ];

package/dist/executer/main-process-user.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMainProcessUser = exports.parseProcessStatusUser = void 0;
+const stream_1 = require("stream");
+// `uid:gid` from the text of /proc/<pid>/status (effective ids), or null.
+function parseProcessStatusUser(status) {
+    const uid = status.match(/^Uid:\s+\d+\s+(\d+)/m);
+    const gid = status.match(/^Gid:\s+\d+\s+(\d+)/m);
+    if (!uid || !gid) {
+        return null;
+    }
+    return `${uid[1]}:${gid[1]}`;
+}
+exports.parseProcessStatusUser = parseProcessStatusUser;
+// The user the container's main process (PID 1) runs as, read inside the
+// container so user namespaces and rootless docker report the container's ids.
+// Healthchecks run as this user, like a Kubernetes exec probe runs as the
+// container's user: a check run as root could otherwise create files the
+// service then cannot read (RabbitMQ's Erlang cookie). Null when it can't be
+// read (no `cat` in the image, a windows container); the check then runs as
+// the exec default, as before.
+async function getMainProcessUser(container, timeoutMs = 2000) {
+    try {
+        const exec = await container.exec({ Cmd: ['cat', '/proc/1/status'], AttachStdout: true, AttachStderr: true });
+        const stream = await exec.start({ hijack: true, stdin: false });
+        const stdout = new stream_1.PassThrough();
+        const chunks = [];
+        stdout.on('data', (chunk) => chunks.push(chunk));
+        container.modem.demuxStream(stream, stdout, new stream_1.PassThrough());
+        const finished = await Promise.race([
+            new Promise((resolve) => {
+                stream.on('end', () => resolve(true));
+                stream.on('error', () => resolve(false));
+            }),
+            new Promise((resolve) => setTimeout(() => resolve(false), timeoutMs)),
+        ]);
+        if (!finished) {
+            stream.destroy();
+            return null;
+        }
+        const result = await exec.inspect();
+        if (result.ExitCode !== 0) {
+            return null;
+        }
+        return parseProcessStatusUser(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+exports.getMainProcessUser = getMainProcessUser;
+//# sourceMappingURL=main-process-user.js.map

package/dist/index.js

@@ -6,9 +6,18 @@ const get_file_context_1 = require("./file/get-file-context");
 const work_item_status_1 = require("./planner/work-item-status");
 const empty_writable_1 = require("./utils/empty-writable");
 const run_program_1 = require("./run-program");
+const abort_on_signals_1 = require("./utils/abort-on-signals");
 const abortCtrl = new AbortController();
-process.on('SIGINT', function () {
-    abortCtrl.abort();
+(0, abort_on_signals_1.abortOnSignals)(process, abortCtrl);
+let settled = false;
+// A run that never settles (a task waiting on something that can't happen)
+// lets the event loop drain, and Node then exits 0: CI would report success
+// for a build that never finished. Fail loudly instead.
+process.on('beforeExit', () => {
+    if (!settled) {
+        process.stderr.write('hammerkit stopped before the run finished\n');
+        process.exitCode = 1;
+    }
 });
 (0, run_program_1.runProgram)({
     cwd: process.cwd(),
@@ -20,7 +29,10 @@ process.on('SIGINT', function () {
     stdout: process.stdout,
     stderr: process.stderr,
     stdoutColumns: process.stdout.columns,
-}, process.argv, false).catch(() => {
+}, process.argv, false).then(() => {
+    settled = true;
+}, () => {
+    settled = true;
     process.exit(1);
 });
 //# sourceMappingURL=index.js.map

package/dist/kubernetes/apply.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.apply = exports.statusCodeOf = void 0;
+// The client throws an ApiException carrying the HTTP status as `code`; watch
+// errors carry it as `statusCode`.
 function statusCodeOf(e) {
     const err = e;
-    return err?.statusCode ?? err?.response?.statusCode ?? err?.body?.code;
+    return typeof err?.code === 'number' ? err.code : err?.statusCode;
 }
 exports.statusCodeOf = statusCodeOf;
 async function apply(instance, spec) {
     try {
         await instance.objectApi.read(spec);
-        const response = await instance.objectApi.patch(spec);
-        return response.body;
+        return await instance.objectApi.patch(spec);
     }
     catch (e) {
         try {
-            const response = await instance.objectApi.create(spec);
-            return response.body;
+            return await instance.objectApi.create(spec);
         }
         catch (createError) {
             // Two work items can apply the same object concurrently (e.g. a volume
@@ -23,8 +23,7 @@ async function apply(instance, spec) {
             // lost the create race, the object now exists — read it back instead of
             // failing the whole item.
             if (statusCodeOf(createError) === 409) {
-                const response = await instance.objectApi.read(spec);
-                return response.body;
+                return await instance.objectApi.read(spec);
             }
             throw createError;
         }

package/dist/kubernetes/await-running-state.js

@@ -4,25 +4,21 @@ exports.deleteJobAndWait = exports.awaitDeployRunningState = exports.deleteJob =
 const abort_1 = require("../executer/abort");
 const abort_event_1 = require("../utils/abort-event");
 const apply_1 = require("./apply");
-function awaitRunningState(instance, env, name, phase) {
-    return new Promise((resolve, reject) => {
-        const req = instance.watch.watch(`/api/v1/namespaces/${env.namespace}/pods`, {}, (type, obj) => {
-            if (obj.metadata.name === name && obj.metadata.namespace === env.namespace && obj.status.phase === phase) {
-                req.then((r) => r.abort());
-                resolve();
-            }
-        }, (err) => {
-            if (err.message === 'aborted') {
-                return;
-            }
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve();
-            }
-        });
-    });
+const sleep_1 = require("../utils/sleep");
+// The waits below poll instead of using the client's Watch: Watch aborts every
+// request after 30s, which a pod or deployment still pulling its image outlasts.
+async function awaitRunningState(instance, env, name, phase, pollInterval = 1000) {
+    for (;;) {
+        const pod = await instance.coreApi.readNamespacedPod({ name, namespace: env.namespace });
+        const current = pod.status?.phase;
+        if (current === phase) {
+            return;
+        }
+        if (current === 'Succeeded' || current === 'Failed') {
+            throw new Error(`pod ${name} ended in phase ${current} before reaching ${phase}`);
+        }
+        await (0, sleep_1.sleep)(pollInterval);
+    }
 }
 exports.awaitRunningState = awaitRunningState;
 // Wait for a job to finish by polling its status: resolves once it succeeded,
@@ -35,8 +31,8 @@ async function awaitJobCompletion(instance, env, name, abort, pollInterval = 100
             await deleteJob(instance, env, name);
             throw new abort_1.AbortError();
         }
-        const job = await instance.batchApi.readNamespacedJobStatus(name, env.namespace);
-        const status = job.body.status;
+        const job = await instance.batchApi.readNamespacedJobStatus({ name, namespace: env.namespace });
+        const status = job.status;
         if (status?.succeeded) {
             return;
         }
@@ -66,7 +62,12 @@ function sleep(ms, abort) {
 }
 async function deleteJob(instance, env, name) {
     try {
-        await instance.batchApi.deleteNamespacedJob(name, env.namespace, undefined, undefined, 0, undefined, 'Background');
+        await instance.batchApi.deleteNamespacedJob({
+            name,
+            namespace: env.namespace,
+            gracePeriodSeconds: 0,
+            propagationPolicy: 'Background',
+        });
     }
     catch (e) {
         if ((0, apply_1.statusCodeOf)(e) !== 404) {
@@ -75,29 +76,32 @@ async function deleteJob(instance, env, name) {
     }
 }
 exports.deleteJob = deleteJob;
-function awaitDeployRunningState(instance, env, name) {
-    return new Promise((resolve, reject) => {
-        const req = instance.watch.watch(`/apis/apps/v1/namespaces/${env.namespace}/deployments`, {}, (type, obj) => {
-            if ((obj &&
-                obj.metadata?.name === name &&
-                obj.metadata?.namespace === env.namespace &&
-                obj.status?.readyReplicas) ??
-                0 > 0) {
-                req.then((r) => r.abort());
-                resolve();
-            }
-        }, (err) => {
-            if (err && err.message === 'aborted') {
-                return;
-            }
-            if (err) {
-                reject(err);
+// Waits for a ready replica. The deadline only starts once a pod runs, so an
+// image pull doesn't count against it (as on docker, where it starts after
+// the container started).
+async function awaitDeployRunningState(instance, env, name, readiness, pollInterval = 1000, now = Date.now) {
+    let runningSince = null;
+    for (;;) {
+        const deployment = await instance.appsApi.readNamespacedDeployment({ name, namespace: env.namespace });
+        if ((deployment.status?.readyReplicas ?? 0) > 0) {
+            return;
+        }
+        if (readiness.timeout !== null) {
+            if (runningSince === null) {
+                const pods = await instance.coreApi.listNamespacedPod({
+                    namespace: env.namespace,
+                    labelSelector: readiness.podSelector,
+                });
+                if (pods.items.some((pod) => pod.status?.phase === 'Running')) {
+                    runningSince = now();
+                }
             }
-            else {
-                resolve();
+            else if (now() - runningSince >= readiness.timeout) {
+                throw new Error(readiness.timeoutMessage);
             }
-        });
-    });
+        }
+        await (0, sleep_1.sleep)(pollInterval);
+    }
 }
 exports.awaitDeployRunningState = awaitDeployRunningState;
 // Delete a job and wait until it is gone: its name is reused for the task's next
@@ -107,7 +111,7 @@ async function deleteJobAndWait(instance, env, name, abort, pollInterval = 500)
     await deleteJob(instance, env, name);
     for (;;) {
         try {
-            await instance.batchApi.readNamespacedJob(name, env.namespace);
+            await instance.batchApi.readNamespacedJob({ name, namespace: env.namespace });
         }
         catch (e) {
             if ((0, apply_1.statusCodeOf)(e) === 404) {

package/dist/kubernetes/ensure-http-route.js

@@ -5,15 +5,12 @@ const apply_1 = require("./apply");
 const resources_1 = require("./resources");
 exports.HTTP_ROUTE_API_VERSION = 'gateway.networking.k8s.io/v1';
 exports.HTTP_ROUTE_KIND = 'HTTPRoute';
-async function ensureHttpRoute(instance, env, ingress, service) {
-    if (!ingress.gateway) {
-        throw new Error(`httproute for ${ingress.host} requires a "gateway" (the parent Gateway name)`);
-    }
+async function ensureHttpRoute(instance, env, route, service) {
     const resource = {
         apiVersion: exports.HTTP_ROUTE_API_VERSION,
         kind: exports.HTTP_ROUTE_KIND,
         metadata: {
-            name: ingress.host,
+            name: route.host,
             namespace: env.namespace,
             labels: {
                 'hammerkit.dev/id': service.id(),
@@ -22,25 +19,25 @@ async function ensureHttpRoute(instance, env, ingress, service) {
         spec: {
             parentRefs: [
                 {
-                    name: ingress.gateway,
-                    ...(ingress.gatewayNamespace ? { namespace: ingress.gatewayNamespace } : {}),
+                    name: route.gateway,
+                    ...(route.gatewayNamespace ? { namespace: route.gatewayNamespace } : {}),
                 },
             ],
-            hostnames: [ingress.host],
+            hostnames: [route.host],
             rules: [
                 {
                     matches: [
                         {
                             path: {
                                 type: 'PathPrefix',
-                                value: ingress.path ?? '/',
+                                value: route.path ?? '/',
                             },
                         },
                     ],
                     backendRefs: [
                         {
                             name: (0, resources_1.getResourceName)(service),
-                            port: ingress.servicePort ?? service.data.ports[0].containerPort,
+                            port: route.servicePort ?? service.data.ports[0].containerPort,
                         },
                     ],
                 },

package/dist/kubernetes/ensure-kubernetes-deployment-exists.js

@@ -2,12 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureKubernetesDeploymentExists = void 0;
 const work_item_1 = require("../planner/work-item");
+const work_service_1 = require("../planner/work-service");
 const apply_1 = require("./apply");
 const get_service_ip_1 = require("./get-service-ip");
 const version_1 = require("../version");
 const replace_env_variables_1 = require("../environment/replace-env-variables");
 const await_running_state_1 = require("./await-running-state");
 const resources_1 = require("./resources");
+const work_healthcheck_1 = require("../planner/work-healthcheck");
 async function ensureKubernetesDeploymentExists(instance, env, service, persistence, stateKey) {
     const hostAliases = [];
     for (const need of service.needs) {
@@ -25,10 +27,12 @@ async function ensureKubernetesDeploymentExists(instance, env, service, persiste
     }
     const envs = (0, replace_env_variables_1.getEnvironmentVariables)(service.data.envs);
     const name = (0, resources_1.getResourceName)(service);
-    const probe = service.data.healthcheck
+    const healthcheckCommand = (0, work_service_1.getHealthcheckCommand)(service.data);
+    const serviceCommand = (0, work_service_1.getServiceCommand)(service.data);
+    const probe = healthcheckCommand
         ? {
             exec: {
-                command: [service.data.healthcheck.cmd.parsed.command, ...service.data.healthcheck.cmd.parsed.args],
+                command: healthcheckCommand,
             },
             periodSeconds: 5,
             failureThreshold: 3,
@@ -68,13 +72,12 @@ async function ensureKubernetesDeploymentExists(instance, env, service, persiste
                         {
                             name: service.name.replace(/:/, '-'),
                             image: service.data.image,
-                            workingDir: service.data.cwd ?? undefined,
+                            workingDir: (0, work_service_1.getServiceWorkingDir)(service.data),
                             env: Object.entries(envs).map(([key, value]) => ({
                                 name: key,
                                 value: value,
                             })),
-                            command: service.data.cmd ? [service.data.cmd.parsed.command] : undefined,
-                            args: service.data.cmd ? service.data.cmd.parsed.args : undefined,
+                            ...getKubernetesCommand(serviceCommand),
                             ports: service.data.ports.map((p) => ({
                                 containerPort: p.containerPort,
                             })),
@@ -99,7 +102,25 @@ async function ensureKubernetesDeploymentExists(instance, env, service, persiste
     if (deploy.status?.readyReplicas ?? 0 > 0) {
         return;
     }
-    await (0, await_running_state_1.awaitDeployRunningState)(instance, env, name);
+    await (0, await_running_state_1.awaitDeployRunningState)(instance, env, name, {
+        podSelector: `hammerkit.dev/id=${service.id()}`,
+        timeout: service.data.healthcheck?.timeout ?? null,
+        timeoutMessage: service.data.healthcheck
+            ? (0, work_healthcheck_1.getHealthcheckTimeoutMessage)(service.name, service.data.healthcheck)
+            : '',
+    });
 }
 exports.ensureKubernetesDeploymentExists = ensureKubernetesDeploymentExists;
+// Kubernetes `command` replaces the image entrypoint and `args` its command.
+// A shell service sets both; an exec-form `cmd` keeps the established mapping
+// (first token as `command`, the rest as `args`).
+function getKubernetesCommand(command) {
+    if (command.entrypoint && command.cmd) {
+        return { command: command.entrypoint, args: command.cmd };
+    }
+    if (command.cmd) {
+        return { command: [command.cmd[0]], args: command.cmd.slice(1) };
+    }
+    return {};
+}
 //# sourceMappingURL=ensure-kubernetes-deployment-exists.js.map

package/dist/kubernetes/ensure-namespace.js

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureNamespace = void 0;
-function statusCodeOf(e) {
-    const err = e;
-    return err?.statusCode ?? err?.response?.statusCode ?? err?.body?.code;
-}
+const apply_1 = require("./apply");
 /**
  * Idempotently make sure `namespace` exists. hammerkit does not otherwise
  * create namespaces — deployments/services/jobs are applied straight into
@@ -16,25 +13,27 @@ function statusCodeOf(e) {
  */
 async function ensureNamespace(instance, namespace) {
     try {
-        await instance.coreApi.readNamespace(namespace);
+        await instance.coreApi.readNamespace({ name: namespace });
         return;
     }
     catch (e) {
-        if (statusCodeOf(e) !== 404) {
+        if ((0, apply_1.statusCodeOf)(e) !== 404) {
             throw e;
         }
     }
     try {
         await instance.coreApi.createNamespace({
-            metadata: {
-                name: namespace,
-                labels: { 'hammerkit.dev/managed': 'true' },
+            body: {
+                metadata: {
+                    name: namespace,
+                    labels: { 'hammerkit.dev/managed': 'true' },
+                },
             },
         });
     }
     catch (e) {
         // another worker created it between our read and create
-        if (statusCodeOf(e) !== 409) {
+        if ((0, apply_1.statusCodeOf)(e) !== 409) {
             throw e;
         }
     }

package/dist/kubernetes/ensure-persistent-data.js

@@ -10,6 +10,7 @@ const sleep_1 = require("../utils/sleep");
 const version_1 = require("../version");
 const log_1 = require("../log");
 const ensure_kubernetes_persistent_volume_claim_exists_1 = require("./ensure-kubernetes-persistent-volume-claim-exists");
+const stream_1 = require("stream");
 // A previous run that crashed between creating an upload/download pod and its
 // `finally` cleanup leaves a pod behind under the same deterministic name. apply()
 // would then patch that stale pod in place — and if it is stuck in a terminal
@@ -17,7 +18,7 @@ const ensure_kubernetes_persistent_volume_claim_exists_1 = require("./ensure-kub
 // and wait for it to disappear before scheduling a fresh one.
 async function removeStalePod(instance, namespace, name) {
     try {
-        await instance.coreApi.deleteNamespacedPod(name, namespace, undefined, undefined, 0);
+        await instance.coreApi.deleteNamespacedPod({ name, namespace, gracePeriodSeconds: 0 });
     }
     catch (e) {
         if ((0, apply_1.statusCodeOf)(e) === 404) {
@@ -27,7 +28,7 @@ async function removeStalePod(instance, namespace, name) {
     }
     for (let attempt = 0; attempt < 30; attempt++) {
         try {
-            await instance.coreApi.readNamespacedPod(name, namespace);
+            await instance.coreApi.readNamespacedPod({ name, namespace });
         }
         catch (e) {
             if ((0, apply_1.statusCodeOf)(e) === 404) {
@@ -100,7 +101,7 @@ async function getPodForPersistence(instance, env, service, persistence, type, f
     }
     finally {
         service.status.console('stdout', `delete pod ${name}`);
-        await instance.coreApi.deleteNamespacedPod(name, env.namespace);
+        await instance.coreApi.deleteNamespacedPod({ name, namespace: env.namespace });
     }
 }
 exports.getPodForPersistence = getPodForPersistence;
@@ -122,12 +123,12 @@ async function ensurePersistentData(instance, env, environment, service, persist
                 continue;
             }
             const fileItem = (0, path_1.basename)(source.localPath);
-            const data = (0, tar_1.create)({
+            const data = stream_1.Readable.from((0, tar_1.create)({
                 cwd: (0, path_1.dirname)(source.localPath),
                 filter(path) {
                     return source.matcher(path, source.localPath);
                 },
-            }, [fileItem]);
+            }, [fileItem]));
             service.status.console('stdout', `upload ${source.localPath}`);
             const targetPath = `/dev/hammerkit/${service.id()}`;
             const res = await instance.exec.exec(env.namespace, name, 'volume', ['tar', 'xf', '-', '-C', targetPath], process.stdout, process.stderr, data, false, (status) => {

package/dist/kubernetes/get-service-ip.js

@@ -4,8 +4,8 @@ exports.getServiceIp = void 0;
 const resources_1 = require("./resources");
 async function getServiceIp(instance, env, workService) {
     const name = (0, resources_1.getResourceName)(workService);
-    const svc = await instance.coreApi.readNamespacedService(name, env.namespace);
-    return svc.body.spec?.clusterIP ?? null;
+    const svc = await instance.coreApi.readNamespacedService({ name, namespace: env.namespace });
+    return svc.spec?.clusterIP ?? null;
 }
 exports.getServiceIp = getServiceIp;
 //# sourceMappingURL=get-service-ip.js.map

package/dist/kubernetes/kubernetes-instance.js

@@ -16,14 +16,10 @@ function createKubernetesInstances(kubernetes) {
         const coreApi = kc.makeApiClient(client_node_1.CoreV1Api);
         const batchApi = kc.makeApiClient(client_node_1.BatchV1Api);
         const appsApi = kc.makeApiClient(client_node_1.AppsV1Api);
-        const networkingApi = kc.makeApiClient(client_node_1.NetworkingV1Api);
         const objectApi = kc.makeApiClient(client_node_1.KubernetesObjectApi);
         const exec = new client_node_1.Exec(kc);
-        const watch = new client_node_1.Watch(kc);
         return {
             objectApi,
-            networkingApi,
-            watch,
             exec,
             appsApi,
             coreApi,

package/dist/kubernetes/remove-persistent-data.js

@@ -2,16 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removePersistentData = void 0;
 async function removePersistentData(instance, kubernetes, task) {
-    const configmaps = await instance.coreApi.listNamespacedConfigMap(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-    for (const configMap of configmaps.body.items) {
+    const labelSelector = `hammerkit.dev/id=${task.id()}`;
+    const configmaps = await instance.coreApi.listNamespacedConfigMap({ namespace: kubernetes.namespace, labelSelector });
+    for (const configMap of configmaps.items) {
         if (configMap.metadata?.name) {
-            await instance.coreApi.deleteNamespacedConfigMap(configMap.metadata.name, kubernetes.namespace);
+            await instance.coreApi.deleteNamespacedConfigMap({
+                name: configMap.metadata.name,
+                namespace: kubernetes.namespace,
+            });
         }
     }
-    const pvcs = await instance.coreApi.listNamespacedPersistentVolumeClaim(kubernetes.namespace, undefined, undefined, undefined, undefined, `hammerkit.dev/id=${task.id()}`);
-    for (const pvc of pvcs.body.items) {
+    const pvcs = await instance.coreApi.listNamespacedPersistentVolumeClaim({
+        namespace: kubernetes.namespace,
+        labelSelector,
+    });
+    for (const pvc of pvcs.items) {
         if (pvc.metadata?.name) {
-            await instance.coreApi.deleteNamespacedPersistentVolumeClaim(pvc.metadata.name, kubernetes.namespace);
+            await instance.coreApi.deleteNamespacedPersistentVolumeClaim({
+                name: pvc.metadata.name,
+                namespace: kubernetes.namespace,
+            });
         }
     }
 }