hammerkit 1.5.1 → 1.6.0-alpha.2

package/specs/task/watching/spec.md

@@ -0,0 +1,69 @@
+# Feature Specification: Task: Watching
+
+**Feature Branch**: `001-current-state-specs`
+
+**Created**: 2026-05-30
+
+**Status**: Current State (reverse-specified from docs, hammerkit 1.6.0)
+
+**Input**: Existing behavior documented in `docs/task/watching.md`
+
+## User Scenarios & Testing *(mandatory)*
+
+### User Story 1 - Restart a task automatically on source file changes (Priority: P1)
+
+A developer runs an API server task and wants it to restart whenever the source code changes. They run `hammerkit <task> --watch`. Hammerkit watches the task's declared `src` files and folders; when a change is detected it restarts the task.
+
+**Why this priority**: Watch mode is the primary developer-experience feature for iterative development workflows.
+
+**Independent Test**: Start a task with `--watch` and a `src` folder; modify a file in the folder and observe that the task process is terminated and restarted.
+
+**Acceptance Scenarios**:
+
+1. **Given** a task with `src` defined and the `--watch` flag, **When** a file in `src` changes, **Then** hammerkit terminates the running task and restarts it.
+2. **Given** a task with `src` defined and the `--watch` flag, **When** no files change, **Then** the task continues running without interruption.
+
+### User Story 2 - Mark a self-managing task as continuous (Priority: P2)
+
+A developer uses Angular CLI's `ng serve` which handles its own file watching and incremental rebuilding internally. They mark the task with `continuous: true`. When watch mode is active, hammerkit does not watch the `src` directory for that task, allowing the tool to manage its own restart cycle.
+
+**Why this priority**: Self-managing tasks (Angular, webpack --watch, etc.) would otherwise be redundantly restarted by hammerkit on top of their own internal watching, causing conflicts.
+
+**Independent Test**: Mark a task `continuous: true` and run with `--watch`; modify a source file and verify hammerkit does NOT restart the task process (the task handles its own reload).
+
+**Acceptance Scenarios**:
+
+1. **Given** a task with `continuous: true` and the `--watch` flag, **When** a file in `src` changes, **Then** hammerkit does NOT restart the task process.
+2. **Given** a task with `continuous: true` but WITHOUT `--watch`, **When** the task is run normally, **Then** the `continuous` flag has no visible effect on single-run behavior.
+3. **Given** a mix of continuous and non-continuous tasks in watch mode, **When** a source file for the non-continuous task changes, **Then** only the non-continuous task is restarted.
+
+### Edge Cases
+
+- A task without `src` declared has nothing to watch; behavior with `--watch` and no `src` is not specified (assumed to run once and stay alive without restart triggers).
+- `continuous: true` only suppresses hammerkit-level file watching; it does not affect how the task's process itself behaves.
+- Watch mode with a container task follows the same restart semantics as a local task.
+
+## Requirements *(mandatory)*
+
+### Functional Requirements
+
+- **FR-001**: The system MUST support a `--watch` CLI flag on the execute command.
+- **FR-002**: When `--watch` is active, the system MUST monitor the `src` files and folders of a task for changes.
+- **FR-003**: When a change is detected in watched sources, the system MUST terminate the running task process and restart it.
+- **FR-004**: The system MUST accept a `continuous: true` field on a task.
+- **FR-005**: When a task has `continuous: true` and watch mode is active, the system MUST NOT watch the task's `src` for changes or restart it.
+
+## Success Criteria *(mandatory)*
+
+### Measurable Outcomes
+
+- **SC-001**: Modifying a source file of a watched non-continuous task causes the task to restart within a reasonable detection window.
+- **SC-002**: Modifying a source file of a watched continuous task does NOT cause hammerkit to restart that task process.
+- **SC-003**: A task without `continuous: true` runs and restarts under `--watch` as expected.
+
+## Assumptions
+
+- Watch mode monitors the same `src` paths used for caching; the two features share source declarations.
+- The file-system polling or event mechanism used for watching is an implementation detail not described in the docs.
+- `continuous: true` is intended for tasks that have their own internal watch loop (e.g., webpack, ng serve, jest --watch).
+- Watch mode operates for the lifetime of the hammerkit process; Ctrl-C stops watching and terminates all running tasks.

package/dist/console/console-context-mock.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.consoleContextMock = void 0;
-/* eslint-disable @typescript-eslint/no-empty-function */
-function consoleContextMock() {
-    return {
-        warn() { },
-        info() { },
-        error() { },
-        debug() { },
-    };
-}
-exports.consoleContextMock = consoleContextMock;
-//# sourceMappingURL=console-context-mock.js.map

package/dist/environment/get-process-env.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extendHostVariables = void 0;
-function extendHostVariables(envs, ctx) {
-    const result = { ...envs };
-    for (const key of ['PATH']) {
-        const value = ctx.processEnvs[key];
-        if (!result[key] && value) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-exports.extendHostVariables = extendHostVariables;
-//# sourceMappingURL=get-process-env.js.map

package/dist/executer/create-scheduler-state.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSchedulerState = void 0;
-const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
-const check_for_loop_1 = require("./scheduler/check-for-loop");
-const state_1 = require("./state");
-function createSchedulerState(input) {
-    const state = {
-        service: {},
-        node: {},
-        cacheMethod: input.cacheMethod,
-        watch: input.watch,
-    };
-    for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(input.nodes)) {
-        state.node[node.id] = {
-            type: 'pending',
-            node: node,
-            stateKey: null,
-        };
-    }
-    for (const service of (0, plan_work_nodes_1.iterateWorkServices)(input.services)) {
-        state.service[service.id] = {
-            type: 'pending',
-            service,
-            stateKey: null,
-        };
-    }
-    (0, check_for_loop_1.checkForLoop)(state);
-    return new state_1.State(state);
-}
-exports.createSchedulerState = createSchedulerState;
-//# sourceMappingURL=create-scheduler-state.js.map

package/dist/executer/docker-node.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dockerNode = void 0;
-const service_dns_1 = require("./service-dns");
-const execute_docker_1 = require("./execute-docker");
-const abort_1 = require("./abort");
-const write_work_node_cache_1 = require("../optimizer/write-work-node-cache");
-const log_1 = require("../log");
-const states_1 = require("./states");
-const execution_steps_1 = require("./execution-steps");
-const using_container_1 = require("../docker/using-container");
-const print_container_options_1 = require("./print-container-options");
-function buildCreateOptions(node, serviceContainers) {
-    const links = [];
-    const hosts = [];
-    for (const need of node.needs) {
-        const dns = serviceContainers[need.id];
-        if ((0, service_dns_1.isHostServiceDns)(dns)) {
-            hosts.push(`${need.name}:${dns.host}`);
-        }
-        else {
-            if (!dns.containerId) {
-                throw new Error(`service ${need.name} is not running`);
-            }
-            links.push(`${dns.containerId}:${need.name}`);
-        }
-    }
-    return {
-        Image: node.image,
-        Tty: true,
-        Entrypoint: node.shell,
-        Cmd: ['-c', 'sleep 3600'],
-        Env: Object.keys(node.envs).map((k) => `${k}=${node.envs[k]}`),
-        WorkingDir: (0, execute_docker_1.convertToPosixPath)(node.cwd),
-        Labels: { app: 'hammerkit', 'hammerkit-id': node.id, 'hammerkit-type': 'task' },
-        HostConfig: {
-            Binds: [
-                ...node.mounts.map((v) => `${v.localPath}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`),
-                ...node.volumes.map((v) => `${v.name}:${(0, execute_docker_1.convertToPosixPath)(v.containerPath)}`),
-            ],
-            PortBindings: node.ports.reduce((map, port) => {
-                map[`${port.containerPort}/tcp`] = [{ HostPort: `${port.hostPort}` }];
-                return map;
-            }, {}),
-            ExtraHosts: hosts,
-            Links: links,
-            AutoRemove: true,
-        },
-        ExposedPorts: node.ports.reduce((map, port) => {
-            map[`${port.containerPort}/tcp`] = {};
-            return map;
-        }, {}),
-    };
-}
-function dockerNode(node, stateKey, serviceContainers, state, environment) {
-    return async (abort, started) => {
-        const status = environment.status.task(node);
-        status.write('info', `execute ${node.name} in container`);
-        try {
-            await (0, execution_steps_1.prepareMounts)(node, environment);
-            (0, abort_1.checkForAbort)(abort.signal);
-            await (0, execution_steps_1.pullImage)(node, environment);
-            (0, abort_1.checkForAbort)(abort.signal);
-            await (0, execution_steps_1.prepareVolume)(node, environment);
-            (0, abort_1.checkForAbort)(abort.signal);
-            const containerOptions = buildCreateOptions(node, serviceContainers);
-            (0, print_container_options_1.printContainerOptions)(status, containerOptions);
-            const success = await (0, using_container_1.usingContainer)(environment, node, containerOptions, async (container) => {
-                await (0, execution_steps_1.setUserPermissions)(node, container, environment);
-                for (const cmd of node.cmds) {
-                    (0, abort_1.checkForAbort)(abort.signal);
-                    status.write('info', `execute cmd "${cmd.cmd}" in container`);
-                    const result = await (0, execute_docker_1.execCommand)(status, environment, container, (0, execute_docker_1.convertToPosixPath)(cmd.path), [node.shell, '-c', cmd.cmd], node.user, undefined, abort.signal);
-                    if (result.type === 'timeout') {
-                        throw new Error(`command ${cmd.cmd} timed out`);
-                    }
-                    if (result.type === 'canceled') {
-                        throw new abort_1.AbortError();
-                    }
-                    if (result.result.ExitCode !== 0) {
-                        state.patchNode({
-                            node,
-                            stateKey,
-                            type: 'crash',
-                            exitCode: result.result.ExitCode ?? 1,
-                        }, stateKey);
-                        return false;
-                    }
-                }
-                return true;
-            });
-            if (success) {
-                await (0, write_work_node_cache_1.writeWorkNodeCache)(node, environment);
-                state.patchNode({
-                    node,
-                    stateKey,
-                    type: 'completed',
-                    cached: false,
-                    duration: (0, states_1.getDuration)(started),
-                }, stateKey);
-            }
-        }
-        catch (e) {
-            if (e instanceof abort_1.AbortError) {
-                state.patchNode({
-                    node,
-                    stateKey,
-                    type: 'canceled',
-                }, stateKey);
-            }
-            else {
-                state.patchNode({
-                    node,
-                    stateKey,
-                    type: 'error',
-                    errorMessage: (0, log_1.getErrorMessage)(e),
-                }, stateKey);
-            }
-        }
-    };
-}
-exports.dockerNode = dockerNode;
-//# sourceMappingURL=docker-node.js.map

package/dist/executer/hierarchy-scheduler.js

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.schedule = void 0;
-const work_service_1 = require("../planner/work-service");
-const docker_service_1 = require("./docker-service");
-const kubernetes_service_1 = require("./kubernetes-service");
-const work_node_1 = require("../planner/work-node");
-const docker_node_1 = require("./docker-node");
-const local_node_1 = require("./local-node");
-const work_node_status_1 = require("../planner/work-node-status");
-async function schedule(processManager, state, environment) {
-    state.on((currentState) => {
-        for (const [, nodeState] of Object.entries(currentState.node)) {
-            if (nodeState.type === 'pending') {
-                const endedNeeds = nodeState.node.needs
-                    .map((need) => currentState.service[need.id])
-                    .filter((service) => service.type === 'end');
-                if (endedNeeds.length > 0) {
-                    state.patchNode({
-                        type: 'canceled',
-                        node: nodeState.node,
-                    });
-                    continue;
-                }
-                const pendingNeeds = nodeState.node.needs
-                    .map((need) => currentState.service[need.id])
-                    .filter((service) => service.type === 'pending');
-                const hasOpenDeps = nodeState.node.deps.some((dep) => currentState.node[dep.id].type !== 'completed');
-                if (hasOpenDeps) {
-                    continue;
-                }
-                if (pendingNeeds.length > 0) {
-                    // TODO do not start, if needs are cached
-                    for (const pendingNeed of pendingNeeds) {
-                        const ctx = (0, work_node_status_1.logContext)('service', pendingNeed.service);
-                        state.patchService({
-                            type: 'running',
-                            service: pendingNeed.service,
-                            abortController: processManager.background(ctx, (0, work_service_1.isContainerWorkService)(pendingNeed.service)
-                                ? (0, docker_service_1.dockerService)(pendingNeed.service, state, environment)
-                                : (0, kubernetes_service_1.kubernetesService)(pendingNeed.service, state, environment)),
-                        });
-                    }
-                    continue;
-                }
-                const hasNotReadyNeeds = nodeState.node.needs.some((need) => currentState.service[need.id].type !== 'ready');
-                if (hasNotReadyNeeds) {
-                    continue;
-                }
-                const serviceContainers = {};
-                for (const need of nodeState.node.needs) {
-                    const serviceState = currentState.service[need.id];
-                    if (serviceState.type === 'ready') {
-                        serviceContainers[need.id] = serviceState.dns;
-                    }
-                }
-                const ctx = (0, work_node_status_1.logContext)('task', nodeState.node);
-                state.patchNode({
-                    type: 'starting',
-                    node: nodeState.node,
-                    started: new Date(),
-                    abortController: (0, work_node_1.isContainerWorkNode)(nodeState.node)
-                        ? processManager.task(ctx, (0, docker_node_1.dockerNode)(nodeState.node, serviceContainers, state, environment))
-                        : processManager.task(ctx, (0, local_node_1.localNode)(nodeState.node, state, environment)),
-                });
-            }
-        }
-        for (const [serviceId, serviceState] of Object.entries(currentState.service)) {
-            if (serviceState.type !== 'ready' && serviceState.type !== 'running') {
-                continue;
-            }
-            let hasNeed = false;
-            for (const nodeState of Object.values(currentState.node)) {
-                if (nodeState.type === 'running' || nodeState.type === 'starting' || nodeState.type === 'pending') {
-                    if (nodeState.node.needs.some((n) => n.id === serviceId)) {
-                        hasNeed = true;
-                    }
-                }
-            }
-            if (!hasNeed) {
-                environment.status.service(serviceState.service).write('info', 'stop unused service');
-                serviceState.abortController.abort();
-            }
-        }
-    });
-    await processManager.onComplete();
-    const success = !Object.values(state.current.node).some((n) => n.type !== 'completed');
-    return {
-        state: state.current,
-        success,
-    };
-}
-exports.schedule = schedule;
-//# sourceMappingURL=hierarchy-scheduler.js.map

package/dist/executer/local-node.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.localNode = void 0;
-const abort_1 = require("./abort");
-const execute_command_1 = require("./execute-command");
-const write_work_node_cache_1 = require("../optimizer/write-work-node-cache");
-const log_1 = require("../log");
-const states_1 = require("./states");
-function localNode(node, stateKey, state, environment) {
-    return async (abort, started) => {
-        const status = environment.status.task(node);
-        status.write('info', `execute ${node.name} locally`);
-        try {
-            for (const cmd of node.cmds) {
-                (0, abort_1.checkForAbort)(abort.signal);
-                status.write('info', `execute cmd "${cmd.cmd}" locally`);
-                const exitCode = await (0, execute_command_1.executeCommand)(status, abort.signal, cmd.path, cmd.cmd, node.envs);
-                if (exitCode !== 0) {
-                    state.patchNode({
-                        type: 'crash',
-                        node,
-                        exitCode,
-                        stateKey,
-                    }, stateKey);
-                    return;
-                }
-            }
-            await (0, write_work_node_cache_1.writeWorkNodeCache)(node, environment);
-            state.patchNode({
-                type: 'completed',
-                node: node,
-                cached: false,
-                stateKey,
-                duration: (0, states_1.getDuration)(started),
-            }, stateKey);
-        }
-        catch (e) {
-            if (e instanceof abort_1.AbortError) {
-                state.patchNode({
-                    type: 'canceled',
-                    node,
-                    stateKey,
-                }, stateKey);
-            }
-            else {
-                state.patchNode({
-                    type: 'error',
-                    node,
-                    stateKey,
-                    errorMessage: (0, log_1.getErrorMessage)(e),
-                }, stateKey);
-            }
-        }
-    };
-}
-exports.localNode = localNode;
-//# sourceMappingURL=local-node.js.map

package/dist/executer/schedule.js

@@ -1,137 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.schedule = void 0;
-const work_service_1 = require("../planner/work-service");
-const docker_service_1 = require("./docker-service");
-const kubernetes_service_1 = require("./kubernetes-service");
-const work_node_1 = require("../planner/work-node");
-const docker_node_1 = require("./docker-node");
-const local_node_1 = require("./local-node");
-const work_node_status_1 = require("../planner/work-node-status");
-const start_watch_processes_1 = require("../start-watch-processes");
-const start_node_1 = require("./start-node");
-async function schedule(processManager, state, environment) {
-    if (state.current.watch) {
-        (0, start_watch_processes_1.startWatchProcesses)(state, processManager, environment);
-    }
-    state.on((currentState) => {
-        for (const [, nodeState] of Object.entries(currentState.node)) {
-            if (nodeState.type === 'pending') {
-                const hasOpenDeps = nodeState.node.deps.some((dep) => currentState.node[dep.id].type !== 'completed');
-                if (hasOpenDeps) {
-                    continue;
-                }
-                state.patchNode({
-                    type: 'starting',
-                    node: nodeState.node,
-                    started: new Date(),
-                    stateKey: null,
-                }, nodeState.stateKey);
-                processManager.background({
-                    type: 'task',
-                    name: nodeState.node.name,
-                    id: nodeState.node.id + '-cache',
-                }, async (abort) => {
-                    await (0, start_node_1.startNode)(nodeState, state, environment, abort.signal);
-                });
-            }
-            else if (nodeState.type === 'ready') {
-                const endedNeeds = nodeState.node.needs
-                    .map((need) => currentState.service[need.id])
-                    .filter((service) => service.type === 'end' || service.type === 'canceled');
-                if (endedNeeds.length > 0) {
-                    state.patchNode({
-                        type: 'error',
-                        node: nodeState.node,
-                        stateKey: nodeState.stateKey,
-                        errorMessage: endedNeeds
-                            .map((n) => `service ${n.service.name} ${n.type === 'end' ? 'has ended ' + n.reason : 'was canceled'}`)
-                            .join(', '),
-                    }, nodeState.stateKey);
-                    continue;
-                }
-                const pendingNeeds = nodeState.node.needs
-                    .map((need) => currentState.service[need.id])
-                    .filter((service) => service.type === 'pending');
-                if (pendingNeeds.length > 0) {
-                    for (const pendingNeed of pendingNeeds) {
-                        state.patchService({
-                            type: 'starting',
-                            service: pendingNeed.service,
-                            stateKey: null,
-                        });
-                        processManager.background({
-                            type: 'service',
-                            name: pendingNeed.service.name,
-                            id: pendingNeed.service.id + '-cache',
-                        }, async (abort) => {
-                            await (0, start_node_1.startService)(pendingNeed.service, state, environment, abort.signal);
-                        });
-                    }
-                    continue;
-                }
-                const hasNotReadyNeeds = nodeState.node.needs.some((need) => currentState.service[need.id].type !== 'running');
-                if (hasNotReadyNeeds) {
-                    continue;
-                }
-                const serviceContainers = {};
-                for (const need of nodeState.node.needs) {
-                    const serviceState = currentState.service[need.id];
-                    if (serviceState.type === 'running') {
-                        serviceContainers[need.id] = serviceState.dns;
-                    }
-                }
-                state.patchNode({
-                    type: 'running',
-                    node: nodeState.node,
-                    stateKey: nodeState.stateKey,
-                    started: nodeState.started,
-                }, nodeState.stateKey);
-                const ctx = (0, work_node_status_1.logContext)('task', nodeState.node);
-                if ((0, work_node_1.isContainerWorkNode)(nodeState.node)) {
-                    processManager.task(ctx, (0, docker_node_1.dockerNode)(nodeState.node, nodeState.stateKey, serviceContainers, state, environment));
-                }
-                else {
-                    processManager.task(ctx, (0, local_node_1.localNode)(nodeState.node, nodeState.stateKey, state, environment));
-                }
-            }
-        }
-        for (const [serviceId, serviceState] of Object.entries(currentState.service)) {
-            if (serviceState.type === 'ready') {
-                const ctx = (0, work_node_status_1.logContext)('service', serviceState.service);
-                state.patchService({
-                    type: 'starting',
-                    service: serviceState.service,
-                    stateKey: serviceState.stateKey,
-                });
-                processManager.background(ctx, (0, work_service_1.isContainerWorkService)(serviceState.service)
-                    ? (0, docker_service_1.dockerService)(serviceState.service, serviceState.stateKey, state, environment)
-                    : (0, kubernetes_service_1.kubernetesService)(serviceState.service, serviceState.stateKey, state, environment));
-            }
-            if (serviceState.type !== 'ready' && serviceState.type !== 'running') {
-                continue;
-            }
-            let hasNeed = false;
-            for (const nodeState of Object.values(currentState.node)) {
-                if (nodeState.type === 'running' || nodeState.type === 'starting' || nodeState.type === 'pending') {
-                    if (nodeState.node.needs.some((n) => n.id === serviceId)) {
-                        hasNeed = true;
-                    }
-                }
-            }
-            if (!hasNeed) {
-                const ctx = (0, work_node_status_1.logContext)('service', serviceState.service);
-                environment.status.service(serviceState.service).write('info', 'stop unused service');
-                processManager.abort(ctx);
-            }
-        }
-    });
-    await processManager.onComplete();
-    const success = !Object.values(state.current.node).some((n) => n.type !== 'completed');
-    return {
-        state: state.current,
-        success,
-    };
-}
-exports.schedule = schedule;
-//# sourceMappingURL=schedule.js.map

package/dist/executer/start-node.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startService = exports.startNode = void 0;
-const enqueue_next_1 = require("./scheduler/enqueue-next");
-const states_1 = require("./states");
-const work_service_1 = require("../planner/work-service");
-const get_work_node_cache_stats_1 = require("../optimizer/get-work-node-cache-stats");
-async function startNode(node, state, environment, abortSignal) {
-    const cacheState = await (0, enqueue_next_1.checkCacheState)(node.node, state.current.cacheMethod, environment);
-    const currentState = state.current.node[node.node.id];
-    if (abortSignal.aborted) {
-        return;
-    }
-    if (!!currentState.stateKey && currentState.stateKey !== cacheState.stateKey) {
-        const status = environment.status.task(node.node);
-        status.write('debug', `cache check for ${node.node.name} no longer valid, skipping result`);
-        return;
-    }
-    if (cacheState.cached) {
-        state.patchNode({
-            type: 'completed',
-            node: node.node,
-            cached: true,
-            stateKey: cacheState.stateKey,
-            duration: currentState.type === 'starting' ? (0, states_1.getDuration)(currentState.started) : 0,
-        }, node.stateKey);
-    }
-    else {
-        state.patchNode({
-            type: 'ready',
-            node: node.node,
-            stateKey: cacheState.stateKey,
-            started: currentState.type === 'starting' ? currentState.started : new Date(),
-        }, node.stateKey);
-    }
-}
-exports.startNode = startNode;
-async function startService(service, state, environment, abortSignal) {
-    const currentStats = await (0, get_work_node_cache_stats_1.getServiceNodeCacheStats)(service, environment);
-    const stateKey = (0, get_work_node_cache_stats_1.getStateKey)(currentStats, state.current.cacheMethod);
-    if (abortSignal.aborted) {
-        return;
-    }
-    if (!(0, work_service_1.isContainerWorkService)(service)) {
-        state.patchService({
-            type: 'ready',
-            service,
-            stateKey,
-        });
-        return;
-    }
-    const fileStats = await (0, get_work_node_cache_stats_1.getServiceNodeCacheStats)(service, environment);
-    const fileStateKey = (0, get_work_node_cache_stats_1.getStateKey)(fileStats, 'checksum');
-    const currentState = state.current.service[service.id];
-    if (!!currentState.stateKey && currentState.stateKey !== fileStateKey) {
-        const status = environment.status.service(service);
-        status.write('debug', `cache check for ${service.name} no longer valid, skipping result`);
-        return;
-    }
-    state.patchService({
-        type: 'ready',
-        service,
-        stateKey: fileStateKey,
-    });
-}
-exports.startService = startService;
-//# sourceMappingURL=start-node.js.map

package/dist/executer/watch-node.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.watchNode = void 0;
-const get_work_node_cache_stats_1 = require("../optimizer/get-work-node-cache-stats");
-const debouncer_1 = require("../utils/debouncer");
-const path_1 = require("path");
-const abort_event_1 = require("../utils/abort-event");
-function watchNode(node, state, processManager, environment) {
-    return async (abort) => {
-        const status = environment.status.task(node);
-        let currentState = await (0, get_work_node_cache_stats_1.getWorkNodeCacheStats)(node, environment);
-        const debouncer = new debouncer_1.Debouncer(async () => {
-            if (environment.abortCtrl.signal.aborted) {
-                return;
-            }
-            const newStats = await (0, get_work_node_cache_stats_1.getWorkNodeCacheStats)(node, environment);
-            const currentFileState = (0, get_work_node_cache_stats_1.getCacheState)(status, { name: node.name, caching: node.caching ?? state.current.cacheMethod }, currentState, newStats);
-            currentState = newStats;
-            const currentNodeState = state.current.node[node.id];
-            if (currentNodeState.stateKey === currentFileState.stateKey) {
-                return;
-            }
-            status.write('debug', `source changed for node ${node.name}, restart process`);
-            state.resetNode({
-                type: 'pending',
-                node,
-                stateKey: currentFileState.stateKey,
-            });
-        }, 100);
-        const fileWatchers = [];
-        const sources = [];
-        for (const src of node.src) {
-            status.write('debug', `watch ${src.absolutePath} source`);
-            const watcher = environment.file.watch(src.absolutePath, async (fileName) => {
-                const absoluteFileName = (0, path_1.join)(src.absolutePath, fileName);
-                if (src.matcher(absoluteFileName, node.cwd)) {
-                    status.write('debug', `source ${absoluteFileName} change for watched task ${node.name}`);
-                    debouncer.bounce();
-                }
-            });
-            sources.push(src.absolutePath);
-            fileWatchers.push(watcher);
-        }
-        await (0, abort_event_1.waitOnAbort)(abort.signal);
-        debouncer.clear();
-        for (const watcher of fileWatchers) {
-            watcher.close();
-        }
-        return {
-            type: 'node-watch-canceled',
-            node,
-        };
-    };
-}
-exports.watchNode = watchNode;
-//# sourceMappingURL=watch-node.js.map