hammerkit 1.5.1 → 1.6.0-alpha.1

package/dist/executer/get-service-env-hints.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceEnvHints = void 0;
+const service_dns_1 = require("./service-dns");
+function toEnvKey(name) {
+    return name
+        .toUpperCase()
+        .replace(/[^A-Z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+}
+function getServiceEnvHints(needs) {
+    const env = {};
+    for (const need of needs) {
+        const state = need.service.state.current;
+        if (state.type !== 'running') {
+            continue;
+        }
+        const key = toEnvKey(need.name);
+        const host = (0, service_dns_1.isHostServiceDns)(state.dns) ? state.dns.host : '127.0.0.1';
+        env[`HAMMERKIT_${key}_HOST`] = host;
+        const ports = need.service.data.ports;
+        if (ports.length > 0) {
+            const primary = ports.find((p) => p.hostPort !== null) ?? ports[0];
+            const primaryPort = primary.hostPort ?? primary.containerPort;
+            env[`HAMMERKIT_${key}_PORT`] = `${primaryPort}`;
+            for (const port of ports) {
+                const portValue = port.hostPort ?? port.containerPort;
+                env[`HAMMERKIT_${key}_PORT_${port.containerPort}`] = `${portValue}`;
+            }
+        }
+    }
+    return env;
+}
+exports.getServiceEnvHints = getServiceEnvHints;
+//# sourceMappingURL=get-service-env-hints.js.map

package/dist/executer/get-service-env-hints.spec.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_service_env_hints_1 = require("./get-service-env-hints");
+const state_1 = require("./state");
+function makeNeed(name, state, ports = []) {
+    const service = {
+        id: () => name,
+        name,
+        data: { ports },
+        state: new state_1.State(state),
+    };
+    return { name, service };
+}
+describe('getServiceEnvHints', () => {
+    it('returns nothing for non-running needs', () => {
+        const needs = [makeNeed('db', { type: 'pending', stateKey: null })];
+        expect((0, get_service_env_hints_1.getServiceEnvHints)(needs)).toEqual({});
+    });
+    it('emits a localhost host hint for docker container services', () => {
+        const needs = [
+            makeNeed('db', { type: 'running', stateKey: 'k', remote: null, dns: { containerId: 'abc' } }, [
+                { hostPort: 5432, containerPort: 5432 },
+            ]),
+        ];
+        expect((0, get_service_env_hints_1.getServiceEnvHints)(needs)).toEqual({
+            HAMMERKIT_DB_HOST: '127.0.0.1',
+            HAMMERKIT_DB_PORT: '5432',
+            HAMMERKIT_DB_PORT_5432: '5432',
+        });
+    });
+    it('uses the dns host for host-style services', () => {
+        const needs = [
+            makeNeed('api', { type: 'running', stateKey: 'k', remote: null, dns: { host: '10.0.0.7' } }, [
+                { hostPort: null, containerPort: 8080 },
+            ]),
+        ];
+        expect((0, get_service_env_hints_1.getServiceEnvHints)(needs)).toEqual({
+            HAMMERKIT_API_HOST: '10.0.0.7',
+            HAMMERKIT_API_PORT: '8080',
+            HAMMERKIT_API_PORT_8080: '8080',
+        });
+    });
+    it('exposes every published port under its container-port suffix', () => {
+        const needs = [
+            makeNeed('web', { type: 'running', stateKey: 'k', remote: null, dns: { containerId: 'x' } }, [
+                { hostPort: 8080, containerPort: 80 },
+                { hostPort: 8443, containerPort: 443 },
+            ]),
+        ];
+        const env = (0, get_service_env_hints_1.getServiceEnvHints)(needs);
+        expect(env).toEqual({
+            HAMMERKIT_WEB_HOST: '127.0.0.1',
+            HAMMERKIT_WEB_PORT: '8080',
+            HAMMERKIT_WEB_PORT_80: '8080',
+            HAMMERKIT_WEB_PORT_443: '8443',
+        });
+    });
+    it('sanitizes weird names into env-safe keys', () => {
+        const needs = [
+            makeNeed('my.service:1', { type: 'running', stateKey: 'k', remote: null, dns: { containerId: 'x' } }, []),
+        ];
+        expect((0, get_service_env_hints_1.getServiceEnvHints)(needs)).toEqual({ HAMMERKIT_MY_SERVICE_1_HOST: '127.0.0.1' });
+    });
+});
+//# sourceMappingURL=get-service-env-hints.spec.js.map

package/dist/executer/kubernetes-service.js

@@ -1,64 +1,132 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.kubernetesService = void 0;
-const child_process_1 = require("child_process");
+const net_1 = require("net");
+const client_node_1 = require("@kubernetes/client-node");
 const log_1 = require("../log");
-const abort_event_1 = require("../utils/abort-event");
-const sleep_1 = require("../utils/sleep");
-function kubernetesService(service, stateKey, state, env) {
-    return async (abort) => {
-        const status = env.status.service(service);
-        do {
-            await startForward(service, stateKey, state, status, abort);
-            if (!abort.signal.aborted) {
-                await (0, sleep_1.sleep)(1000);
-            }
-        } while (!abort.signal.aborted);
-    };
+const resolve_pod_name_1 = require("../kubernetes/resolve-pod-name");
+function loadKubeConfig(service) {
+    const kc = new client_node_1.KubeConfig();
+    if (service.kubeconfig) {
+        kc.loadFromFile(service.kubeconfig);
+    }
+    else {
+        kc.loadFromDefault();
+    }
+    kc.setCurrentContext(service.context);
+    return kc;
 }
-exports.kubernetesService = kubernetesService;
-function startForward(service, stateKey, state, status, abort) {
-    const cmd = `kubectl port-forward ${service.selector.type}/${service.selector.name} --kubeconfig ${service.kubeconfig} --context ${service.context} ${service.ports.map((p) => `${p.hostPort}:${p.containerPort}`).join(' ')}`;
-    const ps = (0, child_process_1.exec)(cmd, {});
-    return new Promise((resolve) => {
-        ps.stdout?.on('data', async (data) => {
-            for (const log of (0, log_1.getLogs)(data)) {
-                status.console('stdout', log);
+async function startForwardServer(forward, namespace, podName, hostPort, containerPort, item) {
+    const sockets = new Set();
+    const server = (0, net_1.createServer)((socket) => {
+        sockets.add(socket);
+        // retryCount=0 selects PortForward's non-restartable input path: a simple
+        // synchronous ws.send per chunk. The retryCount=1 path uses
+        // restartableHandleStandardInput, whose internal `queue.then(...)` chain has
+        // NO `.catch` (see web-socket-handler.js processData TODO) so a closed WS
+        // becomes an unhandled rejection ("can't send data to ws") that crashes the
+        // whole process. We catch ws errors/close ourselves and close both sides
+        // together so the event loop drains on teardown.
+        let ws = null;
+        socket.on('close', () => {
+            sockets.delete(socket);
+            try {
+                ws?.close?.();
             }
-            state.patchService({
-                service,
-                type: 'running',
-                dns: { host: 'host-gateway' },
-                stateKey,
-            });
-        });
-        ps.stderr?.on('data', async (data) => {
-            for (const log of (0, log_1.getLogs)(data)) {
-                status.console('stderr', log);
+            catch {
+                /* already closing */
             }
         });
-        ps.on('error', (err) => {
-            status.write('error', (0, log_1.getErrorMessage)(err));
-            state.patchService({
-                service,
-                type: 'end',
-                reason: 'crash',
-                stateKey,
-            });
+        socket.on('error', (err) => {
+            item.status.write('debug', `port-forward socket error: ${(0, log_1.getErrorMessage)(err)}`);
         });
-        ps.on('close', (code) => {
-            status.write('info', `exit with ${code}`);
-            state.patchService({
-                service,
-                type: 'end',
-                reason: 'crash',
-                stateKey,
+        forward
+            .portForward(namespace, podName, [containerPort], socket, null, socket, 0)
+            .then((opened) => {
+            ws = opened;
+            const w = ws;
+            w?.on?.('error', (err) => {
+                item.status.write('debug', `port-forward ws error: ${(0, log_1.getErrorMessage)(err)}`);
+                socket.destroy();
             });
+            w?.on?.('close', () => socket.destroy());
+        })
+            .catch((err) => {
+            item.status.write('error', `port-forward failed: ${(0, log_1.getErrorMessage)(err)}`);
+            socket.destroy();
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(hostPort, '127.0.0.1', () => {
+            server.off('error', reject);
             resolve();
         });
     });
-    (0, abort_event_1.listenOnAbort)(abort.signal, () => {
-        ps.kill();
+    return { hostPort, containerPort, server, sockets };
+}
+function closeForwardServer(fs) {
+    for (const socket of fs.sockets) {
+        socket.destroy();
+    }
+    return new Promise((resolve) => {
+        fs.server.close(() => resolve());
+    });
+}
+async function kubernetesService(service, options) {
+    const kc = loadKubeConfig(service.data);
+    const forward = new client_node_1.PortForward(kc);
+    const coreApi = kc.makeApiClient(client_node_1.CoreV1Api);
+    const appsApi = kc.makeApiClient(client_node_1.AppsV1Api);
+    let podName;
+    try {
+        podName = await (0, resolve_pod_name_1.resolvePodName)(coreApi, appsApi, service.data.namespace, service.data.selector);
+    }
+    catch (e) {
+        service.status.write('error', (0, log_1.getErrorMessage)(e));
+        options.state.set({
+            type: 'error',
+            stateKey: options.stateKey,
+            errorMessage: (0, log_1.getErrorMessage)(e),
+        });
+        return;
+    }
+    const servers = [];
+    try {
+        for (const port of service.data.ports) {
+            if (port.hostPort === null) {
+                continue;
+            }
+            const fs = await startForwardServer(forward, service.data.namespace, podName, port.hostPort, port.containerPort, service);
+            servers.push(fs);
+            service.status.write('info', `forwarding 127.0.0.1:${port.hostPort} -> ${podName}:${port.containerPort}`);
+        }
+    }
+    catch (e) {
+        service.status.write('error', `failed to start port-forward: ${(0, log_1.getErrorMessage)(e)}`);
+        await Promise.all(servers.map(closeForwardServer));
+        options.state.set({ type: 'error', stateKey: options.stateKey, errorMessage: (0, log_1.getErrorMessage)(e) });
+        return;
+    }
+    options.state.set({
+        type: 'running',
+        dns: { host: '127.0.0.1' },
+        stateKey: options.stateKey,
+        remote: null,
     });
+    try {
+        await new Promise((resolve) => {
+            if (options.abort.aborted) {
+                resolve();
+                return;
+            }
+            options.abort.addEventListener('abort', () => resolve(), { once: true });
+        });
+    }
+    finally {
+        await Promise.all(servers.map(closeForwardServer));
+        options.state.set({ type: 'end', reason: 'terminated', stateKey: options.stateKey });
+    }
 }
+exports.kubernetesService = kubernetesService;
 //# sourceMappingURL=kubernetes-service.js.map

package/dist/executer/label-values.js

@@ -1,65 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchesAnyLabel = exports.hasDependencyWithMatch = exports.hasNeedsWithMatch = exports.matchesAllLabels = exports.hasLabels = void 0;
+exports.mergeLabels = exports.appliesToLabels = exports.matchesAnyLabel = exports.hasLabels = void 0;
 function hasLabels(labels) {
     return Object.keys(labels).length > 0;
 }
 exports.hasLabels = hasLabels;
-function matchesAllLabels(filterLabels, node, nodes) {
-    for (const [labelKey, filterValues] of Object.entries(filterLabels)) {
-        const nodeValues = node.labels[labelKey];
-        if (nodeValues === null || nodeValues === undefined || nodeValues.length === 0) {
-            if (!hasNeedsWithMatch(node, nodes, (depNode) => matchesAllLabels(filterLabels, depNode, nodes))) {
-                return false;
-            }
-        }
-        for (const nodeValue of nodeValues || []) {
-            if (filterValues.indexOf(nodeValue) === -1) {
-                if (!hasNeedsWithMatch(node, nodes, (depNode) => matchesAllLabels(filterLabels, depNode, nodes))) {
-                    return false;
-                }
-            }
+function matchesAnyLabel(filter, value) {
+    for (const [labelKey, filterValues] of Object.entries(filter)) {
+        const labelValues = value[labelKey];
+        if (labelValues === null || labelValues === undefined || labelValues.length === 0) {
+            continue;
         }
-    }
-    return true;
-}
-exports.matchesAllLabels = matchesAllLabels;
-function hasNeedsWithMatch(root, nodes, matcher) {
-    for (const node of Object.values(nodes)) {
-        if (node.deps.some((d) => d.id === root.id)) {
-            if (matcher(node)) {
+        for (const labelValue of labelValues) {
+            if (filterValues.indexOf(labelValue) >= 0) {
                 return true;
             }
         }
     }
     return false;
 }
-exports.hasNeedsWithMatch = hasNeedsWithMatch;
-function hasDependencyWithMatch(root, matcher) {
-    for (const dep of root.deps) {
-        if (matcher(dep)) {
-            return true;
-        }
-    }
-    return false;
+exports.matchesAnyLabel = matchesAnyLabel;
+function appliesToLabels(labels, options) {
+    return ((!hasLabels(options.filterLabels ?? {}) || matchesAnyLabel(options.filterLabels ?? {}, labels)) &&
+        !matchesAnyLabel(options.excludeLabels ?? {}, labels));
 }
-exports.hasDependencyWithMatch = hasDependencyWithMatch;
-function matchesAnyLabel(filterLabels, node) {
-    if (!hasLabels(filterLabels)) {
-        return false;
-    }
-    for (const [labelKey, filterValues] of Object.entries(filterLabels)) {
-        const nodeValues = node.labels[labelKey];
-        if (nodeValues === null || nodeValues === undefined || nodeValues.length === 0) {
-            continue;
-        }
-        for (const nodeValue of nodeValues) {
-            if (filterValues.indexOf(nodeValue) >= 0) {
-                return true;
+exports.appliesToLabels = appliesToLabels;
+function mergeLabels(...sources) {
+    const result = {};
+    for (const source of sources) {
+        for (const [key, value] of Object.entries(source || {})) {
+            const arrayValue = value instanceof Array ? value : [`${value}`];
+            if (!result[key]) {
+                result[key] = arrayValue;
+            }
+            else {
+                for (const item of arrayValue) {
+                    if (result[key].indexOf(item) === -1) {
+                        result[key].push(item);
+                    }
+                }
             }
         }
     }
-    return hasDependencyWithMatch(node, (depNode) => matchesAnyLabel(filterLabels, depNode));
+    return result;
 }
-exports.matchesAnyLabel = matchesAnyLabel;
+exports.mergeLabels = mergeLabels;
 //# sourceMappingURL=label-values.js.map

package/dist/executer/label-values.spec.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const label_values_1 = require("./label-values");
+describe('label-values', () => {
+    describe('hasLabels', () => {
+        it('is false for an empty object', () => {
+            expect((0, label_values_1.hasLabels)({})).toBe(false);
+        });
+        it('is true when at least one key is present', () => {
+            expect((0, label_values_1.hasLabels)({ app: ['web'] })).toBe(true);
+        });
+    });
+    describe('matchesAnyLabel', () => {
+        it('matches when a filter value is present in the labels', () => {
+            expect((0, label_values_1.matchesAnyLabel)({ app: ['web'] }, { app: ['web', 'api'] })).toBe(true);
+        });
+        it('does not match when the value is absent', () => {
+            expect((0, label_values_1.matchesAnyLabel)({ app: ['web'] }, { app: ['api'] })).toBe(false);
+        });
+        it('skips label keys that are missing or empty on the value', () => {
+            expect((0, label_values_1.matchesAnyLabel)({ app: ['web'] }, {})).toBe(false);
+            expect((0, label_values_1.matchesAnyLabel)({ app: ['web'] }, { app: [] })).toBe(false);
+        });
+        it('returns false for an empty filter', () => {
+            expect((0, label_values_1.matchesAnyLabel)({}, { app: ['web'] })).toBe(false);
+        });
+    });
+    describe('appliesToLabels', () => {
+        it('applies when there is no filter and no exclude', () => {
+            expect((0, label_values_1.appliesToLabels)({ app: ['web'] }, {})).toBe(true);
+        });
+        it('applies only when the filter matches', () => {
+            expect((0, label_values_1.appliesToLabels)({ app: ['web'] }, { filterLabels: { app: ['web'] } })).toBe(true);
+            expect((0, label_values_1.appliesToLabels)({ app: ['web'] }, { filterLabels: { app: ['api'] } })).toBe(false);
+        });
+        it('does not apply when an exclude matches', () => {
+            expect((0, label_values_1.appliesToLabels)({ app: ['web'] }, { excludeLabels: { app: ['web'] } })).toBe(false);
+        });
+        it('exclude wins over a matching filter', () => {
+            expect((0, label_values_1.appliesToLabels)({ app: ['web'], tier: ['frontend'] }, { filterLabels: { app: ['web'] }, excludeLabels: { tier: ['frontend'] } })).toBe(false);
+        });
+    });
+    describe('mergeLabels', () => {
+        it('coerces scalar values into string arrays', () => {
+            expect((0, label_values_1.mergeLabels)({ app: 'web', port: 8080 })).toEqual({ app: ['web'], port: ['8080'] });
+        });
+        it('keeps array values as-is', () => {
+            expect((0, label_values_1.mergeLabels)({ app: ['web', 'api'] })).toEqual({ app: ['web', 'api'] });
+        });
+        it('merges multiple sources and dedupes values', () => {
+            expect((0, label_values_1.mergeLabels)({ app: 'web' }, { app: ['web', 'api'] }, { tier: 'frontend' })).toEqual({
+                app: ['web', 'api'],
+                tier: ['frontend'],
+            });
+        });
+        it('ignores null and undefined sources', () => {
+            expect((0, label_values_1.mergeLabels)(null, undefined, { app: 'web' })).toEqual({ app: ['web'] });
+        });
+    });
+});
+//# sourceMappingURL=label-values.spec.js.map

package/dist/executer/lazy-resolver.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyResolver = void 0;
+function lazyResolver(factory) {
+    let value = null;
+    let resolved = false;
+    return () => {
+        if (!resolved) {
+            value = factory();
+            resolved = true;
+        }
+        return value;
+    };
+}
+exports.lazyResolver = lazyResolver;
+//# sourceMappingURL=lazy-resolver.js.map

package/dist/executer/lazy-resolver.spec.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lazy_resolver_1 = require("./lazy-resolver");
+describe('lazyResolver', () => {
+    it('calls the factory once and memoizes the result', () => {
+        const factory = vi.fn(() => 'value');
+        const resolve = (0, lazy_resolver_1.lazyResolver)(factory);
+        expect(resolve()).toBe('value');
+        expect(resolve()).toBe('value');
+        expect(factory).toHaveBeenCalledTimes(1);
+    });
+    it('memoizes a falsy result so the factory still runs only once', () => {
+        const factory = vi.fn(() => 0);
+        const resolve = (0, lazy_resolver_1.lazyResolver)(factory);
+        expect(resolve()).toBe(0);
+        expect(resolve()).toBe(0);
+        expect(factory).toHaveBeenCalledTimes(1);
+    });
+});
+//# sourceMappingURL=lazy-resolver.spec.js.map

package/dist/executer/local-task.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localTask = void 0;
+const abort_1 = require("./abort");
+const execute_command_1 = require("./execute-command");
+const log_1 = require("../log");
+const replace_env_variables_1 = require("../environment/replace-env-variables");
+const get_service_env_hints_1 = require("./get-service-env-hints");
+async function localTask(item, environment, options) {
+    item.status.write('info', `execute ${item.name} locally`);
+    const envs = { ...(0, replace_env_variables_1.getEnvironmentVariables)(item.data.envs), ...(0, get_service_env_hints_1.getServiceEnvHints)(item.needs) };
+    try {
+        for (const cmd of item.data.cmds) {
+            (0, abort_1.checkForAbort)(options.abort);
+            item.status.write('info', `execute cmd "${cmd.cmd}" locally`);
+            const exitCode = await (0, execute_command_1.executeCommand)(item.status, options.abort, cmd.cwd, cmd.cmd, envs, environment);
+            if (exitCode !== 0) {
+                options.state.set({
+                    type: 'crash',
+                    exitCode,
+                    stateKey: options.stateKey,
+                });
+                return;
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof abort_1.AbortError) {
+            options.state.set({
+                type: 'canceled',
+                stateKey: options.stateKey,
+            });
+        }
+        else {
+            options.state.set({
+                type: 'error',
+                stateKey: options.stateKey,
+                errorMessage: (0, log_1.getErrorMessage)(e),
+            });
+        }
+    }
+}
+exports.localTask = localTask;
+//# sourceMappingURL=local-task.js.map

package/dist/executer/process-manager.js

@@ -1,71 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProcessManager = void 0;
-const abort_event_1 = require("../utils/abort-event");
 const log_1 = require("../log");
 class ProcessManager {
-    constructor(env, workerLimit) {
-        this.env = env;
+    constructor(workerLimit) {
         this.workerLimit = workerLimit;
         this.processes = [];
         this.pendingProcesses = [];
-        this.listeners = [];
     }
-    on(listener) {
-        this.listeners.push(listener);
-    }
-    onComplete() {
-        if (this.processes.length === 0 && this.pendingProcesses.length === 0) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve) => {
-            this.listeners.push((evt, processes, pending) => {
-                if (processes.length === 0 && pending.length === 0) {
-                    resolve();
-                }
-            });
-        });
-    }
-    abort(context) {
-        this.pendingProcesses = this.pendingProcesses.filter((p) => p.context.id !== context.id);
-        const processes = this.processes.filter((p) => p.context.id === context.id);
-        for (const process of processes) {
-            process.abortController.abort();
-        }
-    }
-    background(context, process) {
-        const abortController = new AbortController();
-        (0, abort_event_1.listenOnAbort)(this.env.abortCtrl.signal, () => {
-            abortController.abort();
-        });
-        this.startProcess({ process, context, abortController });
-        return abortController;
-    }
-    task(context, process) {
-        const abortController = new AbortController();
-        (0, abort_event_1.listenOnAbort)(this.env.abortCtrl.signal, () => {
-            abortController.abort();
-        });
-        const hasFreeWorker = this.workerLimit === 0 || this.workerLimit > this.processes.length;
-        if (hasFreeWorker) {
-            const hasBlockingProcess = this.processes.some((p) => p.context.id === context.id);
-            if (hasBlockingProcess) {
-                this.abort(context);
-                this.pendingProcesses.push({ context, process, abortController });
+    task(item, factory) {
+        return new Promise((resolve, reject) => {
+            const hasFreeWorker = this.workerLimit === 0 || this.workerLimit > this.processes.length;
+            if (hasFreeWorker) {
+                this.startProcess({ factory, item, resolve, reject });
             }
             else {
-                this.startProcess({ process, context, abortController });
+                this.pendingProcesses.push({ item, factory, resolve, reject });
             }
-        }
-        else {
-            this.pendingProcesses.push({ context, process, abortController });
-        }
-        return abortController;
+        });
     }
     enqueuePendingProcesses() {
         const nextProcess = this.pendingProcesses[0];
         if (nextProcess) {
-            const hasBlockingProcess = this.processes.some((p) => p.context.id === nextProcess.context.id);
+            const hasBlockingProcess = this.processes.some((p) => p.id === nextProcess.item.name);
             if (hasBlockingProcess) {
                 return;
             }
@@ -76,35 +33,24 @@ class ProcessManager {
         }
     }
     startProcess(pendingProcess) {
-        const started = new Date();
         const item = {
-            context: pendingProcess.context,
-            started,
-            abortController: pendingProcess.abortController,
+            id: pendingProcess.item.name,
             promise: pendingProcess
-                .process(pendingProcess.abortController, started)
+                .factory()
+                .then(() => {
+                pendingProcess.resolve();
+            })
                 .catch((err) => {
-                this.env.status.context(pendingProcess.context).write('error', (0, log_1.getErrorMessage)(err));
+                pendingProcess.item.status.write('error', (0, log_1.getErrorMessage)(err));
+                pendingProcess.reject(err);
             })
                 .finally(() => {
                 const index = this.processes.indexOf(item);
                 this.processes.splice(index, 1);
-                this.notifyListeners({ context: item.context, type: 'ended' });
                 this.enqueuePendingProcesses();
             }),
         };
         this.processes.push(item);
-        this.notifyListeners({ context: item.context, type: 'started' });
-    }
-    notifyListeners(evt) {
-        for (const listener of this.listeners) {
-            try {
-                listener(evt, this.processes, this.pendingProcesses.map((p) => ({ context: p.context })));
-            }
-            catch (e) {
-                this.env.status.context(evt.context).write('error', (0, log_1.getErrorMessage)(e));
-            }
-        }
     }
 }
 exports.ProcessManager = ProcessManager;