hammerkit 1.27.0-next.2 → 1.27.0-next.21

package/dist/harness/task-tools.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskToolArgs = exports.taskToolSchema = exports.createTaskTools = exports.describeTasks = exports.describeRun = exports.readLogHint = exports.readTaskListing = exports.LIST_TASKS_MS = void 0;
+const sandbox_client_1 = require("./sandbox-client");
+// the most tasks a description lists, and of a task's description or command it shows
+const MAX_LISTED = 40;
+const MAX_DESCRIPTION_CHARS = 200;
+const MAX_COMMAND_CHARS = 100;
+// how long a client waits for the tasks of the build file when it starts, it goes on without them
+exports.LIST_TASKS_MS = 15000;
+// The tasks of the published version, or why they could not be read within `ms`.
+async function readTaskListing(list, ms = exports.LIST_TASKS_MS) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`no answer within ${ms / 1000} s`)), ms);
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([list(), timeout]);
+    }
+    catch (e) {
+        return { error: e instanceof Error ? e.message : String(e) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+exports.readTaskListing = readTaskListing;
+// the hint at the end of a cut output or a result, for the model
+function readLogHint(run, task) {
+    return `read more of the log with run_logs { "run": "${run}", "task": "${task}" }`;
+}
+exports.readLogHint = readLogHint;
+// A run of a task in a few lines: how it went, why it ran, its last lines.
+function describeRun(task, ran) {
+    const result = ran.result;
+    const lines = [`run ${ran.run.id}: ${ran.run.state}`];
+    if (result) {
+        lines.push(`task ${task}: ${result.status}` +
+            (result.exitCode !== undefined ? `, exit code ${result.exitCode}` : '') +
+            (result.durationMs !== undefined ? `, ${result.durationMs} ms` : '') +
+            (result.cache?.hit ? ', from the cache' : ''));
+        if (result.error) {
+            lines.push(`error: ${result.error}`);
+        }
+        if (result.cache?.causes?.length) {
+            lines.push(`ran because: ${result.cache.causes.join('; ')}`);
+        }
+    }
+    else if (ran.run.error) {
+        lines.push(`error: ${ran.run.error}`);
+    }
+    if (result && result.lastLog.length > 0) {
+        lines.push('last lines:', ...result.lastLog);
+    }
+    lines.push(readLogHint(ran.run.id, task));
+    return lines.join('\n');
+}
+exports.describeRun = describeRun;
+/**
+ * The tasks for the model, one line each: what it is for (or its command, when the build
+ * file says nothing) and whether it takes arguments. `shell` is left out, the shell tool runs it.
+ */
+function describeTasks(listing, shell) {
+    if (listing === undefined) {
+        return '';
+    }
+    if (!Array.isArray(listing)) {
+        return `The tasks of the build file could not be listed (${listing.error}); name one as the build file does.`;
+    }
+    const tasks = listing.filter((task) => !shell || task.name !== shell);
+    if (tasks.length === 0) {
+        return 'The published build file has no tasks to run.';
+    }
+    const lines = tasks.slice(0, MAX_LISTED).map((task) => {
+        const parts = [`- ${task.name}`];
+        if (task.description) {
+            parts.push(`: ${cut(oneLine(task.description), MAX_DESCRIPTION_CHARS)}`);
+        }
+        else if (task.command) {
+            parts.push(`: runs \`${cut(oneLine(task.command), MAX_COMMAND_CHARS)}\``);
+        }
+        if (task.args === null) {
+            parts.push(' (takes args)');
+        }
+        else if (task.args !== undefined || task.command === null) {
+            parts.push(' (takes no args)');
+        }
+        return parts.join('');
+    });
+    if (tasks.length > MAX_LISTED) {
+        lines.push(`- and ${tasks.length - MAX_LISTED} more`);
+    }
+    return ['The tasks of the published build file:', ...lines].join('\n');
+}
+exports.describeTasks = describeTasks;
+function oneLine(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function cut(text, max) {
+    return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+/**
+ * `run_task`, `run_logs` and `check`, with the tasks the description of `run_task` lists. Without a
+ * listing it names none, as the MCP tools before a version could be read.
+ */
+function createTaskTools(listing, shell) {
+    const tasks = describeTasks(listing, shell);
+    return [
+        {
+            name: 'run_task',
+            title: 'Run a task',
+            description: 'Run a task of the published build file on the sandbox, such as test or build, and answer how it went: ' +
+                'its status, exit code, why it was not taken from the cache, and its last lines. args are appended to ' +
+                'its last command, for example a test file. It runs in the container, with the network and the ' +
+                'options the build file gives the task.' +
+                (tasks ? `\n\n${tasks}` : ''),
+            parameters: {
+                task: { type: 'string', description: 'The name of the task' },
+                args: { type: 'string[]', description: 'Arguments for its last command' },
+            },
+            required: ['task'],
+            async call(client, args, signal) {
+                const ran = await client.runTask(args.task, { args: args.args?.length ? args.args : undefined, signal });
+                return describeRun(args.task, ran);
+            },
+        },
+        {
+            name: 'run_logs',
+            title: 'Read the log of a run',
+            description: 'Read the log of a run as numbered lines: one task, the last lines (tail), a range (from, limit) or ' +
+                'the lines that contain a text (grep, a fixed string) with lines of context around them.',
+            parameters: {
+                run: { type: 'string', description: 'The id of the run' },
+                task: { type: 'string', description: 'Only the lines of this task' },
+                tail: {
+                    type: 'integer',
+                    description: 'The last lines, or with grep the last matches',
+                    minimum: 1,
+                    maximum: 1000,
+                },
+                from: { type: 'integer', description: 'The first line to read', minimum: 1 },
+                limit: { type: 'integer', description: 'How many lines to read', minimum: 1, maximum: 1000 },
+                grep: { type: 'string', description: 'Only lines that contain this text' },
+                ignore_case: { type: 'boolean', description: 'Ignore case in grep' },
+                context: { type: 'integer', description: 'Lines before and after each match', minimum: 0, maximum: 20 },
+            },
+            required: ['run'],
+            async call(client, args) {
+                const page = await client.logs(args.run, {
+                    task: args.task || undefined,
+                    tail: args.tail || undefined,
+                    from: args.from || undefined,
+                    limit: args.limit || undefined,
+                    grep: args.grep || undefined,
+                    i: args.ignore_case || undefined,
+                    context: args.context || undefined,
+                });
+                const lines = page.lines.map((line) => `${line.line}${line.match === false ? '-' : ':'} ${args.task ? '' : `[${line.task}] `}${line.text}`);
+                lines.push('', `(${page.total} lines${args.grep ? ` searched, ${page.lines.filter((line) => line.match !== false).length} match here` : ''}${page.next ? `, read on with from ${page.next}` : ''}${page.truncated ? ', the server cut the log off at its limit' : ''})`);
+                return lines.join('\n');
+            },
+        },
+        {
+            name: 'check',
+            title: 'Run a check',
+            description: sandbox_client_1.CHECK_DESCRIPTION,
+            parameters: { task: { type: 'string', description: 'The name of the task' } },
+            required: ['task'],
+            call(client, args, signal) {
+                return (0, sandbox_client_1.runCheck)(client, args.task, signal);
+            },
+        },
+    ];
+}
+exports.createTaskTools = createTaskTools;
+// The parameters as a JSON schema, for MCP and opencode 2.
+function taskToolSchema(tool) {
+    return {
+        type: 'object',
+        properties: Object.fromEntries(Object.entries(tool.parameters).map(([name, parameter]) => {
+            if (parameter.type === 'string[]') {
+                return [name, { type: 'array', items: { type: 'string' }, description: parameter.description }];
+            }
+            if (parameter.type === 'integer') {
+                const { maximum } = parameter;
+                return [
+                    name,
+                    {
+                        type: 'integer',
+                        description: parameter.description,
+                        minimum: parameter.minimum,
+                        ...(maximum !== undefined ? { maximum } : {}),
+                    },
+                ];
+            }
+            return [name, { type: parameter.type, description: parameter.description }];
+        })),
+        required: tool.required,
+    };
+}
+exports.taskToolSchema = taskToolSchema;
+// The parameters with the zod of opencode 1.
+function taskToolArgs(tool, z) {
+    return Object.fromEntries(Object.entries(tool.parameters).map(([name, parameter]) => {
+        let type;
+        if (parameter.type === 'string[]') {
+            type = z.array(z.string());
+        }
+        else if (parameter.type === 'integer') {
+            type = z.number().int().min(parameter.minimum);
+            type = parameter.maximum !== undefined ? type.max(parameter.maximum) : type;
+        }
+        else {
+            type = parameter.type === 'boolean' ? z.boolean() : z.string();
+        }
+        return [name, (tool.required.includes(name) ? type : type.optional()).describe(parameter.description)];
+    }));
+}
+exports.taskToolArgs = taskToolArgs;
+//# sourceMappingURL=task-tools.js.map

package/dist/kubernetes/apply.js

@@ -36,28 +36,39 @@ exports.apply = apply;
  * of a policy).
  */
 async function replace(instance, spec) {
-    let current;
-    try {
-        current = await instance.objectApi.read(spec);
-    }
-    catch (e) {
-        if (statusCodeOf(e) !== 404) {
-            throw e;
+    for (let attempt = 1;; attempt++) {
+        let current;
+        try {
+            current = await instance.objectApi.read(spec);
+        }
+        catch (e) {
+            if (statusCodeOf(e) !== 404) {
+                throw e;
+            }
+            try {
+                return await instance.objectApi.create(spec);
+            }
+            catch (createError) {
+                if (statusCodeOf(createError) !== 409) {
+                    throw createError;
+                }
+                current = await instance.objectApi.read(spec);
+            }
         }
         try {
-            return await instance.objectApi.create(spec);
+            return await instance.objectApi.replace({
+                ...spec,
+                metadata: { ...spec.metadata, resourceVersion: current.metadata?.resourceVersion },
+            });
         }
-        catch (createError) {
-            if (statusCodeOf(createError) !== 409) {
-                throw createError;
+        catch (e) {
+            // replaced by someone else since it was read (the server sets up a caller's
+            // namespace for a run and for a sandbox at the same time): read it again
+            if (statusCodeOf(e) !== 409 || attempt >= 3) {
+                throw e;
             }
-            current = await instance.objectApi.read(spec);
         }
     }
-    return await instance.objectApi.replace({
-        ...spec,
-        metadata: { ...spec.metadata, resourceVersion: current.metadata?.resourceVersion },
-    });
 }
 exports.replace = replace;
 //# sourceMappingURL=apply.js.map

package/dist/kubernetes/claim-layout.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOutputsFlatteningAlike = exports.hasPathsEndingAlike = exports.byDepth = exports.getClaimSubPath = void 0;
+const crypto_1 = require("crypto");
+const path_1 = require("path");
+const portable_path_1 = require("../planner/utils/portable-path");
+// The paths a work item keeps in its claim. Its consumers mount its outputs by the same
+// paths, so they find the same folders.
+function getClaimPaths(work) {
+    const data = work.data;
+    const paths = [];
+    if ('mounts' in data) {
+        paths.push(...data.mounts.map((mount) => mount.containerPath));
+    }
+    if ('src' in data) {
+        paths.push(...data.src.filter((src) => !src.inherited).map((src) => src.absolutePath));
+    }
+    if ('generates' in data) {
+        paths.push(...data.generates.filter((generate) => !generate.inherited).map((generate) => generate.path));
+    }
+    if ('volumes' in data) {
+        paths.push(...data.volumes.filter((volume) => !volume.inherited).map((volume) => volume.containerPath));
+    }
+    return paths;
+}
+// Where `path` is in the claim of `work`, relative to its root. A path is named after its
+// last segment, so claims without two such paths are laid out as they always were (a
+// service's data among them). Of the paths with the same last segment, the least deep one
+// (then the first in sorted order) keeps the name, and the others also carry a hash of
+// their path. Both go by the path
+// relative to the project, as the task's id does, so a run in another checkout directory
+// (each run of a server has its own) or with its `generates` in another order finds the
+// same folders in a kept claim.
+function getClaimSubPath(work, path) {
+    const name = (0, path_1.basename)(path) || 'root';
+    const alike = getClaimPaths(work).filter((other) => other !== path && (0, path_1.basename)(other) === (0, path_1.basename)(path));
+    if (alike.length === 0) {
+        return name;
+    }
+    const own = (0, portable_path_1.portablePath)(work.data.projectRoot, path);
+    const first = [own, ...alike.map((other) => (0, portable_path_1.portablePath)(work.data.projectRoot, other))].sort(byDepth)[0];
+    if (first === own) {
+        return name;
+    }
+    return `${name}-${(0, crypto_1.createHash)('sha256').update(own).digest('hex').slice(0, 12)}`;
+}
+exports.getClaimSubPath = getClaimSubPath;
+function byDepth(a, b) {
+    return a.split('/').length - b.split('/').length || (a < b ? -1 : a > b ? 1 : 0);
+}
+exports.byDepth = byDepth;
+// Whether two different paths of the claim of `work` end alike. Before getClaimSubPath
+// named them apart, they shared one folder, and outputs made then are mixed.
+function hasPathsEndingAlike(work) {
+    const paths = new Set(getClaimPaths(work));
+    return new Set([...paths].map((path) => (0, path_1.basename)(path))).size < paths.size;
+}
+exports.hasPathsEndingAlike = hasPathsEndingAlike;
+// Whether two outputs of `work` flatten to the same name of a cache archive (`a-b` and
+// `a/b`, see getArchivePaths). Before they were named apart, one archive held both.
+function hasOutputsFlatteningAlike(work) {
+    const data = work.data;
+    if (!('generates' in data) || !('cwd' in data)) {
+        return false;
+    }
+    const paths = new Set(data.generates.filter((generate) => !generate.inherited).map((generate) => generate.path));
+    const names = new Set([...paths].map((path) => (0, path_1.relative)(data.cwd, path).split(path_1.sep).join('-')));
+    return names.size < paths.size;
+}
+exports.hasOutputsFlatteningAlike = hasOutputsFlatteningAlike;
+//# sourceMappingURL=claim-layout.js.map

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

@@ -36,7 +36,7 @@ async function ensureHttpRoute(instance, env, route, service) {
                     ],
                     backendRefs: [
                         {
-                            name: (0, resources_1.getResourceName)(service),
+                            name: (0, resources_1.getResourceName)(service, env),
                             port: route.servicePort ?? service.data.ports[0].containerPort,
                         },
                     ],

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

@@ -21,7 +21,7 @@ async function ensureKubernetesDeploymentExists(instance, env, service, persiste
 // the needed services by name, and the proxy of a limited network
 network) {
     const envs = (0, replace_env_variables_1.getEnvironmentVariables)(service.data.envs);
-    const name = (0, resources_1.getResourceName)(service);
+    const name = (0, resources_1.getResourceName)(service, env);
     const healthcheckCommand = (0, work_service_1.getHealthcheckCommand)(service.data);
     const serviceCommand = (0, work_service_1.getServiceCommand)(service.data, { kubernetes: true });
     const probe = healthcheckCommand
@@ -47,25 +47,21 @@ network) {
                 'hammerkit.dev/version': (0, version_1.getVersion)(),
             },
             labels: {
-                'hammerkit.dev/id': service.id(),
+                ...(0, resources_1.getItemLabels)(service, env),
                 'hammerkit.dev/state': stateKey,
-                ...(0, job_placement_1.getRunLabels)(env),
                 [exports.DEFINITION_LABEL]: (0, service_definition_1.getServiceDefinitionHash)(service),
             },
         },
         spec: {
             selector: {
-                matchLabels: {
-                    'hammerkit.dev/id': service.id(),
-                },
+                matchLabels: (0, resources_1.getItemLabels)(service, env),
             },
             replicas: 1,
             template: {
                 metadata: {
                     labels: {
-                        'hammerkit.dev/id': service.id(),
+                        ...(0, resources_1.getItemLabels)(service, env),
                         'hammerkit.dev/state': stateKey,
-                        ...(0, job_placement_1.getRunLabels)(env),
                         ...workspace.labels,
                         ...(0, network_policy_1.getNetworkLabels)(env, service),
                     },
@@ -127,7 +123,7 @@ network) {
         return;
     }
     await (0, await_running_state_1.awaitDeployRunningState)(instance, env, name, {
-        podSelector: `hammerkit.dev/id=${service.id()}`,
+        podSelector: (0, resources_1.getItemSelector)(service, env),
         timeout: service.data.healthcheck?.timeout ?? null,
         timeoutMessage: service.data.healthcheck
             ? (0, work_healthcheck_1.getHealthcheckTimeoutMessage)(service.name, service.data.healthcheck)

package/dist/kubernetes/ensure-kubernetes-persistent-volume-claim-exists.js

@@ -65,7 +65,7 @@ async function ensureKubernetesPersistentVolumeClaimExists(instance, env, volume
             },
         },
     };
-    service.status.console('stdout', `ensure volume ${volume.name}`);
+    service.status.write('debug', `ensure volume ${volume.name}`);
     // Don't block on the PVC reaching "Bound". Storage classes with
     // volumeBindingMode WaitForFirstConsumer (docker-desktop's "standard",
     // k3d/k3s local-path, most cloud defaults) keep the claim Pending until a pod

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

@@ -4,11 +4,10 @@ exports.ensureKubernetesServiceExists = void 0;
 const apply_1 = require("./apply");
 const resources_1 = require("./resources");
 const version_1 = require("../version");
-const job_placement_1 = require("./job-placement");
 // A service without ports gets a headless Service: a ClusterIP one needs a port,
 // and its tasks reach every port of the pod, as on docker.
 async function ensureKubernetesServiceExists(instance, env, service) {
-    const name = (0, resources_1.getResourceName)(service);
+    const name = (0, resources_1.getResourceName)(service, env);
     const headless = service.data.ports.length === 0;
     const svc = {
         kind: 'Service',
@@ -19,21 +18,19 @@ async function ensureKubernetesServiceExists(instance, env, service) {
             annotations: {
                 'hammerkit.dev/version': (0, version_1.getVersion)(),
             },
-            labels: {
-                'hammerkit.dev/id': service.id(),
-                ...(0, job_placement_1.getRunLabels)(env),
-            },
+            labels: (0, resources_1.getItemLabels)(service, env),
         },
         spec: {
             type: 'ClusterIP',
             ...(headless ? { clusterIP: 'None' } : {}),
-            selector: {
-                'hammerkit.dev/id': service.id(),
-            },
+            // the pods of the service of this run, on a server where runs share the namespace
+            selector: (0, resources_1.getItemLabels)(service, env),
             ...(headless
                 ? {}
                 : {
+                    // a Service of more than one port needs a name for each
                     ports: service.data.ports.map((port) => ({
+                        name: `tcp-${port.hostPort ?? port.containerPort}`,
                         port: port.hostPort ?? port.containerPort,
                         targetPort: port.containerPort,
                     })),

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensurePersistentData = exports.clearClaim = exports.getPodForPersistence = void 0;
+exports.ensurePersistentData = exports.packSource = exports.clearClaim = exports.getPodForPersistence = void 0;
 const apply_1 = require("./apply");
 const path_1 = require("path");
-const tar_1 = require("tar");
+const tar_1 = require("../utils/tar");
 const resources_1 = require("./resources");
 const await_running_state_1 = require("./await-running-state");
 const sleep_1 = require("../utils/sleep");
@@ -67,17 +67,14 @@ async function getPodForPersistence(instance, env, service, persistence, type, f
     for (const volume of persistence.volumes) {
         await (0, ensure_kubernetes_persistent_volume_claim_exists_1.ensureKubernetesPersistentVolumeClaimExists)(instance, env, volume, service, persistence.sizes[volume.name], persistence.kept.includes(volume.name));
     }
-    const name = (0, resources_1.getResourceName)(service, type === 'write' ? '-upload' : '-download');
+    const name = (0, resources_1.getResourceName)(service, env, type === 'write' ? '-upload' : '-download');
     const podSpec = {
         kind: 'Pod',
         apiVersion: 'v1',
         metadata: {
             namespace: env.namespace,
             name,
-            labels: {
-                'hammerkit.dev/id': service.id(),
-                ...(0, job_placement_1.getRunLabels)(env),
-            },
+            labels: (0, resources_1.getItemLabels)(service, env),
             annotations: {
                 'hammerkit.dev/version': (0, version_1.getVersion)(),
             },
@@ -104,18 +101,18 @@ async function getPodForPersistence(instance, env, service, persistence, type, f
             volumes: persistence.volumes,
         },
     };
-    service.status.console('stdout', `create pod ${name}`);
+    service.status.write('debug', `create pod ${name}`);
     await removeStalePod(instance, env.namespace, name);
     const pod = await (0, apply_1.apply)(instance, podSpec);
     if (pod.status?.phase !== 'Running') {
-        service.status.console('stdout', `await running state ${name}`);
+        service.status.write('debug', `await running state ${name}`);
         await (0, await_running_state_1.awaitRunningState)(instance, env, name, 'Running');
     }
     try {
         await fn(name);
     }
     finally {
-        service.status.console('stdout', `delete pod ${name}`);
+        service.status.write('debug', `delete pod ${name}`);
         await instance.coreApi.deleteNamespacedPod({ name, namespace: env.namespace });
     }
 }
@@ -124,7 +121,7 @@ exports.getPodForPersistence = getPodForPersistence;
 // the task runs on it or outputs are restored into it, so it holds what a new one would
 async function clearClaim(instance, env, work, pod) {
     const targetPath = `/dev/hammerkit/${work.id()}`;
-    work.status.console('stdout', `clear what an earlier run left in ${targetPath}`);
+    work.status.write('info', `clear what an earlier run left in ${targetPath}`);
     let failure = null;
     const res = await instance.exec.exec(env.namespace, pod, 'volume', ['find', targetPath, '-mindepth', '1', '-maxdepth', '1', '-exec', 'rm', '-rf', '{}', '+'], process.stdout, process.stderr, null, false, (status) => {
         if (status.status !== 'Success') {
@@ -137,6 +134,25 @@ async function clearClaim(instance, env, work, pod) {
     });
 }
 exports.clearClaim = clearClaim;
+// The archive that uploads a source into the claim: its file or directory, at its place in
+// the claim (see getClaimSubPath) instead of under its own name
+function packSource(source) {
+    const fileItem = (0, path_1.basename)(source.localPath);
+    return stream_1.Readable.from((0, tar_1.packArchive)({
+        cwd: (0, path_1.dirname)(source.localPath),
+        filter(path) {
+            return source.matcher(path, source.localPath);
+        },
+        onWriteEntry(entry) {
+            entry.path = source.subPath + entry.path.slice(fileItem.length);
+            // the second of two hard-linked files links to the first by its path in the archive
+            if (entry.type === 'Link' && entry.linkpath?.startsWith(fileItem)) {
+                entry.linkpath = source.subPath + entry.linkpath.slice(fileItem.length);
+            }
+        },
+    }, [fileItem]));
+}
+exports.packSource = packSource;
 async function ensurePersistentData(instance, env, environment, service, persistence, 
 // the kept claim of the work holds what an earlier run left, which goes first
 options = {}) {
@@ -153,7 +169,7 @@ options = {}) {
     if (persistence.sources.length === 0 && !options.reset) {
         return;
     }
-    service.status.console('stdout', 'start upload container');
+    service.status.write('debug', 'start upload container');
     await getPodForPersistence(instance, env, service, persistence, 'write', async (name) => {
         if (options.reset) {
             await clearClaim(instance, env, service, name);
@@ -163,14 +179,8 @@ options = {}) {
             if (!(await environment.file.exists(source.localPath))) {
                 continue;
             }
-            const fileItem = (0, path_1.basename)(source.localPath);
-            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]));
-            service.status.console('stdout', `upload ${source.localPath}`);
+            const data = packSource(source);
+            service.status.write('info', `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) => {
                 service.status.write('debug', `upload ${source.localPath} to ${name}: ${status}`);

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

@@ -5,7 +5,7 @@ const resources_1 = require("./resources");
 // The address a task reaches the service on: its clusterIP, or for a headless
 // Service (a service without ports) the address of its ready pod.
 async function getServiceIp(instance, env, workService) {
-    const name = (0, resources_1.getResourceName)(workService);
+    const name = (0, resources_1.getResourceName)(workService, env);
     const svc = await instance.coreApi.readNamespacedService({ name, namespace: env.namespace });
     const clusterIP = svc.spec?.clusterIP ?? null;
     if (clusterIP !== 'None') {
@@ -13,7 +13,7 @@ async function getServiceIp(instance, env, workService) {
     }
     const pods = await instance.coreApi.listNamespacedPod({
         namespace: env.namespace,
-        labelSelector: `hammerkit.dev/id=${workService.id()}`,
+        labelSelector: (0, resources_1.getItemSelector)(workService, env),
     });
     const ready = pods.items.find((pod) => !pod.metadata?.deletionTimestamp &&
         pod.status?.podIP &&