hammerkit 1.6.0-alpha.3 → 1.7.0

package/dist/planner/work-graph-serializer.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeWorkGraph = void 0;
+const plan_work_tasks_1 = require("./utils/plan-work-tasks");
+const validate_1 = require("./validate");
+function buildGraph(workTree) {
+    const taskItems = Array.from((0, plan_work_tasks_1.iterateWorkTasks)(workTree)).sort((a, b) => a.name.localeCompare(b.name));
+    const serviceItems = Array.from((0, plan_work_tasks_1.iterateWorkServices)(workTree)).sort((a, b) => a.name.localeCompare(b.name));
+    const nodes = [];
+    const taskNodeId = new Map();
+    const serviceNodeId = new Map();
+    taskItems.forEach((task, index) => {
+        const id = `t${index}`;
+        taskNodeId.set(task.name, id);
+        nodes.push({ id, name: task.name, kind: 'task' });
+    });
+    serviceItems.forEach((service, index) => {
+        const id = `s${index}`;
+        serviceNodeId.set(service.name, id);
+        nodes.push({ id, name: service.name, kind: 'service' });
+    });
+    const edges = [];
+    for (const task of taskItems) {
+        const from = taskNodeId.get(task.name);
+        if (!from) {
+            continue;
+        }
+        for (const dep of task.deps) {
+            const to = taskNodeId.get(dep.name);
+            if (to) {
+                edges.push({ from, to, kind: 'deps' });
+            }
+        }
+        for (const need of task.needs) {
+            const to = serviceNodeId.get(need.service.name);
+            if (to) {
+                edges.push({ from, to, kind: 'needs' });
+            }
+        }
+    }
+    edges.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || a.kind.localeCompare(b.kind));
+    let cycle = null;
+    for (const task of taskItems) {
+        const path = (0, validate_1.hasDependencyCycle)(task, []);
+        if (path && path.length > 0) {
+            cycle = path.map((n) => n.name);
+            break;
+        }
+    }
+    return { nodes, edges, cycle };
+}
+function mermaidLabel(name) {
+    return name.replace(/"/g, "'");
+}
+function renderMermaid(nodes, edges, cycle) {
+    const lines = ['graph TD'];
+    for (const node of nodes) {
+        // tasks are rectangles, services are stadium-shaped, so the two are visually distinct
+        lines.push(node.kind === 'task'
+            ? `  ${node.id}["${mermaidLabel(node.name)}"]`
+            : `  ${node.id}(["${mermaidLabel(node.name)}"])`);
+    }
+    for (const edge of edges) {
+        // deps are solid arrows, needs are dotted — distinct edge types
+        lines.push(edge.kind === 'deps' ? `  ${edge.from} --> ${edge.to}` : `  ${edge.from} -.-> ${edge.to}`);
+    }
+    if (cycle) {
+        lines.push(`  %% cycle detected: ${cycle.join(' -> ')}`);
+    }
+    return lines.join('\n');
+}
+function dotId(id) {
+    return `"${id}"`;
+}
+function dotLabel(name) {
+    return name.replace(/"/g, '\\"');
+}
+function renderDot(nodes, edges, cycle) {
+    const lines = ['digraph hammerkit {'];
+    if (cycle) {
+        lines.push(`  // cycle detected: ${cycle.join(' -> ')}`);
+    }
+    for (const node of nodes) {
+        const shape = node.kind === 'task' ? 'box' : 'ellipse';
+        lines.push(`  ${dotId(node.id)} [label="${dotLabel(node.name)}" shape=${shape}];`);
+    }
+    for (const edge of edges) {
+        const style = edge.kind === 'needs' ? ' [style=dotted]' : '';
+        lines.push(`  ${dotId(edge.from)} -> ${dotId(edge.to)}${style};`);
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+// Serialize the planner's already-built work graph (tasks, services, deps and
+// needs edges) into a renderable format. A cyclic graph still renders and marks
+// the cycle rather than crashing.
+function serializeWorkGraph(workTree, format) {
+    const { nodes, edges, cycle } = buildGraph(workTree);
+    const output = format === 'dot' ? renderDot(nodes, edges, cycle) : renderMermaid(nodes, edges, cycle);
+    return { output, cycle };
+}
+exports.serializeWorkGraph = serializeWorkGraph;
+//# sourceMappingURL=work-graph-serializer.js.map

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+// 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');
+}
+exports.getWorkInstanceId = getWorkInstanceId;
+//# sourceMappingURL=work-instance-id.js.map

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

@@ -9,14 +9,16 @@ const using_container_1 = require("../docker/using-container");
 const event_cache_1 = require("../executer/event-cache");
 const get_docker_executor_1 = require("../executer/get-docker-executor");
 const path_1 = require("path");
+const tar_1 = require("tar");
 const plan_work_volume_1 = require("./utils/plan-work-volume");
+const work_instance_id_1 = require("./work-instance-id");
 function dockerTaskRuntime(task, workEnvironment) {
     const docker = (0, execute_docker_1.getContainerCli)(workEnvironment);
     return {
         async initialize(state) {
             const currentTasks = await docker.listContainers({
                 filters: {
-                    label: [`hammerkit-id=${task.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(task)}`],
                 },
             });
             const currentTask = currentTasks[0];
@@ -40,7 +42,7 @@ function dockerTaskRuntime(task, workEnvironment) {
             const containers = await docker.listContainers({
                 all: true,
                 filters: {
-                    label: [`hammerkit-id=${task.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(task)}`],
                 },
             });
             for (const container of containers) {
@@ -66,11 +68,11 @@ function dockerTaskRuntime(task, workEnvironment) {
                 }
             }
         },
-        async currentStateKey() {
+        async currentStateKey(environment) {
             const containers = await docker.listContainers({
                 all: true,
                 filters: {
-                    label: [`hammerkit-id=${task.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(task)}`],
                 },
             });
             const container = containers[0];
@@ -80,11 +82,26 @@ function dockerTaskRuntime(task, workEnvironment) {
             if (!container.Labels['hammerkit-state']) {
                 return null;
             }
+            // outputs removed since the run (a deleted export, a pruned volume)
+            // leave nothing to reuse
+            for (const generate of task.data.generates.filter((g) => !g.inherited)) {
+                const present = isOnHost(generate)
+                    ? await environment.file.exists(generate.path)
+                    : !!(await (0, get_docker_executor_1.existsVolume)(docker, generate.volumeName));
+                if (!present) {
+                    return null;
+                }
+            }
             return container.Labels['hammerkit-state'];
         },
     };
 }
 exports.dockerTaskRuntime = dockerTaskRuntime;
+// File outputs are bind mounts of host files and exported directories are
+// copied to the host, so both must be present on the host, not only in a volume.
+function isOnHost(generate) {
+    return generate.isFile || generate.export;
+}
 async function restoreContainer(docker, environment, item, path) {
     await (0, using_container_1.usingContainer)(docker, item, {
         abortSignal: environment.abortCtrl.signal,
@@ -95,15 +112,22 @@ async function restoreContainer(docker, environment, item, path) {
         WorkingDir: (0, execute_docker_1.convertToPosixPath)(item.data.cwd),
         Labels: {
             app: 'hammerkit',
-            'hammerkit-id': item.id(),
+            'hammerkit-id': (0, work_instance_id_1.getWorkInstanceId)(item),
             'hammerkit-pid': process.pid.toString(),
             'hammerkit-type': 'task',
         },
         HostConfig: {
             AutoRemove: true,
-            Binds: item.data.type === 'container-task'
-                ? []
-                : [...item.data.volumes.map((v) => `${v.name}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`)],
+            // mount the same volumes archiveContainer reads from, so the restored
+            // archives land in the task's output volumes rather than in this
+            // throwaway container's filesystem
+            Binds: item.data.type === 'container-service'
+                ? item.data.volumes
+                    .filter((v) => !v.inherited)
+                    .map((v) => `${v.name}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`)
+                : item.data.generates
+                    .filter((v) => !v.inherited && !v.isFile)
+                    .map((v) => `${v.volumeName}:${(0, execute_docker_1.convertToPosixPath)(v.path)}`),
         },
     }, null, async (container) => {
         for (const generate of (0, event_cache_1.getArchivePaths)(item.data, path)) {
@@ -114,6 +138,14 @@ async function restoreContainer(docker, environment, item, path) {
             }
         }
     });
+    if (item.data.type === 'container-task') {
+        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 (0, tar_1.extract)({ file: generate.filename, cwd: (0, path_1.dirname)(generate.path) });
+            }
+        }
+    }
 }
 function dockerServiceRuntime(service, workEnvironment) {
     const docker = (0, execute_docker_1.getContainerCli)(workEnvironment);
@@ -121,7 +153,7 @@ function dockerServiceRuntime(service, workEnvironment) {
         async initialize(state) {
             const currentServices = await docker.listContainers({
                 filters: {
-                    label: [`hammerkit-id=${service.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(service)}`],
                 },
             });
             const currentService = currentServices[0];
@@ -143,7 +175,7 @@ function dockerServiceRuntime(service, workEnvironment) {
             const containers = await docker.listContainers({
                 all: true,
                 filters: {
-                    label: [`hammerkit-id=${service.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(service)}`],
                 },
             });
             for (const container of containers) {
@@ -173,7 +205,7 @@ function dockerServiceRuntime(service, workEnvironment) {
             const containers = await docker.listContainers({
                 all: true,
                 filters: {
-                    label: [`hammerkit-id=${service.id()}`],
+                    label: [`hammerkit-id=${(0, work_instance_id_1.getWorkInstanceId)(service)}`],
                 },
             });
             const container = containers[0];
@@ -198,7 +230,7 @@ async function archiveContainer(docker, environment, item, path) {
         WorkingDir: (0, execute_docker_1.convertToPosixPath)(item.data.cwd),
         Labels: {
             app: 'hammerkit',
-            'hammerkit-id': item.id(),
+            'hammerkit-id': (0, work_instance_id_1.getWorkInstanceId)(item),
             'hammerkit-pid': process.pid.toString(),
             'hammerkit-type': 'task',
         },
@@ -213,10 +245,16 @@ async function archiveContainer(docker, environment, item, path) {
                     .map((v) => `${v.volumeName}:${(0, execute_docker_1.convertToPosixPath)(v.path)}`),
         },
     }, null, 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)) {
-            const readable = await container.getArchive({
-                path: generatedArchive.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)])
+                : await container.getArchive({
+                    path: generatedArchive.path,
+                });
             await environment.file.writeStream(generatedArchive.filename, readable);
         }
     });

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

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.kubernetesForwardRuntime = exports.kubernetesServiceRuntime = exports.kubernetesTaskRuntime = void 0;
+const abort_1 = require("../executer/abort");
 const kubernetes_service_1 = require("../executer/kubernetes-service");
 const kubernetes_instance_1 = require("../kubernetes/kubernetes-instance");
 const replace_env_variables_1 = require("../environment/replace-env-variables");
@@ -27,6 +28,10 @@ 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] : []));
+}
 function kubernetesTaskRuntime(task, kubernetes) {
     const instance = (0, kubernetes_instance_1.createKubernetesInstances)(kubernetes);
     return {
@@ -44,6 +49,11 @@ function kubernetesTaskRuntime(task, kubernetes) {
             const persistence = await (0, volumes_1.getKubernetesPersistence)(task);
             await (0, ensure_namespace_1.ensureNamespace)(instance, kubernetes.namespace);
             await (0, ensure_persistent_data_1.ensurePersistentData)(instance, kubernetes, environment, task, persistence);
+            // The last job of a run stays: its state label is what currentStateKey
+            // reads. Jobs from an earlier run of this task go before this one starts.
+            for (const name of await listJobNames(instance, kubernetes, task)) {
+                await (0, await_running_state_1.deleteJobAndWait)(instance, kubernetes, name, options.abort);
+            }
             const podName = `${task.name}-${options.stateKey}`;
             let i = 0;
             for (const cmd of task.data.cmds) {
@@ -95,12 +105,19 @@ function kubernetesTaskRuntime(task, kubernetes) {
                 try {
                     const pod = await (0, apply_1.apply)(instance, spec);
                     if (!pod.status?.succeeded) {
-                        await (0, await_running_state_1.awaitJobState)(instance, kubernetes, spec.metadata.name);
+                        await (0, await_running_state_1.awaitJobCompletion)(instance, kubernetes, spec.metadata.name, options.abort);
                     }
                     task.status.write('debug', 'pod completed');
-                    await instance.batchApi.deleteNamespacedJob(podName, kubernetes.namespace);
+                    if (i < task.data.cmds.length) {
+                        await (0, await_running_state_1.deleteJobAndWait)(instance, kubernetes, podName, options.abort);
+                    }
                 }
                 catch (e) {
+                    if (e instanceof abort_1.AbortError) {
+                        options.state.set({ stateKey: options.stateKey, type: 'canceled' });
+                        return;
+                    }
+                    await (0, await_running_state_1.deleteJob)(instance, kubernetes, podName).catch(() => undefined);
                     options.state.set({
                         stateKey: options.stateKey,
                         type: 'error',
@@ -139,7 +156,22 @@ function kubernetesTaskRuntime(task, kubernetes) {
             const completedStates = jobs.body.items
                 .filter((j) => j.status?.succeeded && j.metadata?.labels?.['hammerkit.dev/state'])
                 .map((j) => j.metadata.labels['hammerkit.dev/state']);
-            return completedStates[completedStates.length - 1] ?? null;
+            const stateKey = completedStates[completedStates.length - 1] ?? null;
+            if (stateKey === null || !task.data.generates.some((g) => !g.inherited)) {
+                return stateKey;
+            }
+            // 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;
+            }
+            catch (e) {
+                if (statusCodeOf(e) === 404) {
+                    return null;
+                }
+                throw e;
+            }
         },
     };
 }

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

@@ -71,10 +71,16 @@ function getLocalWorkRuntime(task) {
         },
         async currentStateKey(environment) {
             const stateFileName = getStateFilename(task);
-            if (await environment.file.exists(stateFileName)) {
-                return await environment.file.read(stateFileName);
+            if (!(await environment.file.exists(stateFileName))) {
+                return null;
             }
-            return Promise.resolve(null);
+            // outputs deleted since the run (rm -rf dist) leave nothing to reuse
+            for (const generate of task.data.generates) {
+                if (!generate.inherited && !(await environment.file.exists(generate.path))) {
+                    return null;
+                }
+            }
+            return await environment.file.read(stateFileName);
         },
         async remove(environment) {
             for (const generate of task.data.generates) {

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

@@ -3,19 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWorkServiceId = void 0;
 const crypto_1 = require("crypto");
 const work_service_1 = require("./work-service");
+const portable_path_1 = require("./utils/portable-path");
+const plan_work_volume_1 = require("./utils/plan-work-volume");
+// Paths are made project-relative (portablePath) so a service id is identical
+// wherever the project is checked out, like a task id.
 function getWorkServiceId(service) {
+    const portable = (path) => (0, portable_path_1.portablePath)(service.projectRoot, path);
     const jsonData = JSON.stringify((0, work_service_1.isContainerWorkService)(service)
         ? {
-            cwd: service.cwd ?? undefined,
+            cwd: portable(service.cwd),
             image: service.image,
-            volumes: service.volumes.map((v) => `${v.name}:${v.containerPath}`).sort(),
-            src: service.src.map((s) => s.absolutePath).sort(),
+            volumes: service.volumes
+                .map((v) => 
+            // a derived volume name hashes the absolute path, so only an
+            // explicitly declared name participates
+            v.name === (0, plan_work_volume_1.getVolumeName)(v.containerPath)
+                ? portable(v.containerPath)
+                : `${v.name}:${portable(v.containerPath)}`)
+                .sort(),
+            src: service.src.map((s) => portable(s.absolutePath)).sort(),
             mounts: service.mounts.map((m) => m.mount).sort(),
         }
         : {
             context: service.context,
             selector: service.selector,
-            kubeconfig: service.kubeconfig,
+            kubeconfig: portable(service.kubeconfig),
         });
     return (0, crypto_1.createHash)('sha1').update(jsonData).digest('hex');
 }