hammerkit 1.5.1 → 1.6.0-alpha.1

package/dist/docker/package.spec.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_case_1 = require("../testing/test-case");
+describe('docker/package', () => {
+    it('should allow sub paths', async () => {
+        const testCase = (0, test_case_1.createTestCase)('package', {
+            'package.json': '{ "dependencies": { "pg": "^8.7.1" } }',
+            'sub/package.json': '{ "dependencies": { "sub": "file://.." } }',
+            '.hammerkit.yaml': {
+                tasks: {
+                    install: {
+                        image: 'node:20-alpine',
+                        cmds: ['npm install'],
+                        src: ['package.json'],
+                        generates: ['node_modules'],
+                    },
+                },
+            },
+            'sub/.hammerkit.yaml': {
+                tasks: {
+                    install: {
+                        deps: ['sub:install'],
+                        image: 'node:20-alpine',
+                        cmds: ['npm install'],
+                        src: ['package.json'],
+                        generates: ['node_modules'],
+                    },
+                },
+                references: {
+                    sub: '..',
+                },
+                services: {
+                    api: {
+                        deps: ['install'],
+                        image: 'node:20-alpine',
+                        labels: { app: 'api' },
+                        cmd: 'node index.js',
+                        src: ['index.js'],
+                        ports: ['3000'],
+                    },
+                },
+            },
+            'sub/index.js': `console.log('hi')`,
+        });
+        await testCase.cli({ filterLabels: { app: ['api'] } }, async (cli) => {
+            await cli.package({
+                registry: 'localhost:5000',
+                push: false,
+                overrideUser: false,
+                username: null,
+                password: null,
+            });
+        });
+    });
+    it('should package and push', async () => {
+        const testCase = (0, test_case_1.createTestCase)('package', {
+            '.hammerkit.yaml': {
+                tasks: {
+                    install: {
+                        image: 'node:20-alpine',
+                        cmds: ['npm install'],
+                        src: ['package.json'],
+                        generates: ['node_modules'],
+                    },
+                },
+                services: {
+                    postgres: {
+                        image: 'postgres:16-alpine',
+                        envs: {
+                            POSTGRES_USER: 'postgres',
+                            POSTGRES_DB: 'demo',
+                            POSTGRES_PASSWORD: '$POSTGRES_PASSWORD',
+                        },
+                        ports: [':5432'],
+                        volumes: ['postgres-db:/var/lib/postgresql/data'],
+                    },
+                    registry: {
+                        image: 'registry:2',
+                        labels: { app: 'registry' },
+                        ports: ['5500:5000'],
+                    },
+                    api: {
+                        deps: ['install'],
+                        needs: ['postgres'],
+                        image: 'node:20-alpine',
+                        labels: { app: 'api' },
+                        envs: {
+                            DATABASE_URL: '$DATABASE_URL',
+                        },
+                        cmd: 'node index.js',
+                        src: ['index.js'],
+                        ports: ['3000'],
+                    },
+                },
+            },
+            'package.json': '{ "dependencies": { "pg": "^8.7.1" } }',
+            '.env': `POSTGRES_PASSWORD=123456
+DATABASE_URL=postgres://postgres:123456@postgres/demo`,
+            'index.js': `const { Client } = require('pg')
+const { createServer } = require('http')
+
+const client = new Client(process.env.DATABASE_URL)
+
+const server = createServer(async (req, res) => {
+  const result = await client.query('SELECT $1::text as message', ['Hello world!'])
+  res.writeHead(200)
+  res.end(result.rows[0].message)
+})
+
+async function main() {
+  await client.connect()
+  server.listen(3000)
+}
+
+process.on('SIGINT', async function () {
+  server.close()
+  await client.end()
+})
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})
+`,
+        });
+        await testCase.cli({ filterLabels: { app: ['registry'] } }, async (cli) => {
+            await cli.runUp({ daemon: true });
+            try {
+                await testCase.cli({ filterLabels: { app: ['api'] } }, async (cli) => {
+                    await cli.package({
+                        registry: 'localhost:5500',
+                        push: true,
+                        overrideUser: true,
+                        username: null,
+                        password: null,
+                    });
+                });
+            }
+            finally {
+                await cli.runDown();
+            }
+        });
+    });
+});
+//# sourceMappingURL=package.spec.js.map

package/dist/docker/pull.js

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pull = void 0;
-async function pull(status, environment, imageName) {
+async function pull(status, docker, imageName) {
     let searchImageName = imageName;
     if (imageName.indexOf(':') === -1) {
         searchImageName += ':latest';
     }
-    const images = await environment.docker.listImages({});
+    const images = await docker.listImages({});
     if (images.some((i) => i.RepoTags?.some((repoTag) => repoTag === searchImageName))) {
         return;
     }
     status.write('debug', `pull image ${imageName}`);
-    const image = await environment.docker.pull(imageName);
+    const image = await docker.pull(imageName);
     await new Promise((resolve, reject) => {
-        environment.docker.modem.followProgress(image, (err, res) => (err ? reject(err) : resolve(res)));
+        docker.modem.followProgress(image, (err, res) => (err ? reject(err) : resolve(res)));
     });
 }
 exports.pull = pull;

package/dist/docker/remove-container.spec.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const remove_container_1 = require("./remove-container");
+function makeContainer(remove) {
+    return { remove };
+}
+describe('removeContainer', () => {
+    it('removes the container on first try', async () => {
+        const remove = vi.fn().mockResolvedValue(undefined);
+        await (0, remove_container_1.removeContainer)(makeContainer(remove));
+        expect(remove).toHaveBeenCalledTimes(1);
+        expect(remove).toHaveBeenCalledWith({ force: true });
+    });
+    it('swallows 404 (already gone)', async () => {
+        const err = Object.assign(new Error('not found'), { statusCode: 404 });
+        const remove = vi.fn().mockRejectedValueOnce(err);
+        await expect((0, remove_container_1.removeContainer)(makeContainer(remove))).resolves.toBeUndefined();
+        expect(remove).toHaveBeenCalledTimes(1);
+    });
+    it('retries on 409 (conflict)', async () => {
+        const conflict = Object.assign(new Error('conflict'), { statusCode: 409 });
+        const remove = vi.fn().mockRejectedValueOnce(conflict).mockResolvedValueOnce(undefined);
+        await (0, remove_container_1.removeContainer)(makeContainer(remove));
+        expect(remove).toHaveBeenCalledTimes(2);
+    }, 5000);
+    it('rethrows unexpected errors', async () => {
+        const err = Object.assign(new Error('boom'), { statusCode: 500 });
+        const remove = vi.fn().mockRejectedValueOnce(err);
+        await expect((0, remove_container_1.removeContainer)(makeContainer(remove))).rejects.toThrow('boom');
+    });
+});
+//# sourceMappingURL=remove-container.spec.js.map

package/dist/docker/stream.js

@@ -18,7 +18,7 @@ exports.logStream = logStream;
 function writeLog(status, level) {
     return async (buffer) => {
         for (const log of (0, log_1.getLogs)(buffer)) {
-            status.console(level, log.endsWith('\n') ? log.substr(0, log.length - 1) : log);
+            status.console(level, log.endsWith('\n') ? log.substring(0, log.length - 1) : log);
         }
     };
 }
@@ -57,8 +57,8 @@ function demuxStream(stream, stdoutFn, stderrFn) {
         }
     }
     function bufferSlice(end) {
-        const out = buffer.slice(0, end);
-        buffer = Buffer.from(buffer.slice(end, buffer.length));
+        const out = buffer.subarray(0, end);
+        buffer = buffer.subarray(end, buffer.length);
         return out;
     }
     stream.on('data', processData);

package/dist/docker/using-container.js

@@ -4,24 +4,42 @@ exports.usingContainer = void 0;
 const remove_container_1 = require("./remove-container");
 const log_1 = require("../log");
 const execute_docker_1 = require("../executer/execute-docker");
-async function usingContainer(environment, node, createOptions, callback) {
-    const status = environment.status.from(node);
+async function usingContainer(docker, item, createOptions, stateKey, callback) {
     let container = null;
+    let succeeded = false;
+    let result;
     try {
-        container = await environment.docker.createContainer(createOptions);
-        status.write('debug', `starting container with image ${node.image}`);
-        await (0, execute_docker_1.startContainer)(status, container);
-        return await callback(container);
+        container = await docker.createContainer(createOptions);
+        item.status.write('debug', `starting container with image ${item.data.image}`);
+        await (0, execute_docker_1.startContainer)(item.status, container);
+        result = await callback(container);
+        succeeded = result !== false;
+        return result;
     }
     finally {
-        if (container) {
-            try {
-                await (0, remove_container_1.removeContainer)(container);
+        try {
+            if (stateKey && succeeded) {
+                if (container) {
+                    await container.pause();
+                }
+                const containers = await docker.listContainers({ all: true, filters: { label: [`hammerkit-id=${item.id()}`] } });
+                for (const container of containers) {
+                    item.status.write('debug', `found container ${container.Id}`);
+                    if (container.Labels['hammerkit-state'] != stateKey) {
+                        const oldContainer = docker.getContainer(container.Id);
+                        await (0, remove_container_1.removeContainer)(oldContainer);
+                    }
+                }
             }
-            catch (e) {
-                status.write('error', `remove of container failed ${(0, log_1.getErrorMessage)(e)}`);
+            else {
+                if (container) {
+                    await (0, remove_container_1.removeContainer)(container);
+                }
             }
         }
+        catch (e) {
+            item.status.write('error', `remove of container failed ${(0, log_1.getErrorMessage)(e)}`);
+        }
     }
 }
 exports.usingContainer = usingContainer;

package/dist/docker/using-container.spec.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const using_container_1 = require("./using-container");
+function makeContainer(id) {
+    return {
+        id,
+        start: vi.fn().mockResolvedValue(undefined),
+        pause: vi.fn().mockResolvedValue(undefined),
+        remove: vi.fn().mockResolvedValue(undefined),
+    };
+}
+function makeDocker(newContainer, listed = []) {
+    const containersById = { [newContainer.id]: newContainer };
+    for (const entry of listed) {
+        containersById[entry.Id] = makeContainer(entry.Id);
+    }
+    return {
+        docker: {
+            createContainer: vi.fn().mockResolvedValue(newContainer),
+            listContainers: vi.fn().mockResolvedValue(listed),
+            getContainer: vi.fn((id) => containersById[id] ?? makeContainer(id)),
+        },
+        containersById,
+    };
+}
+function makeItem(id) {
+    return {
+        id: () => id,
+        name: id,
+        status: { write: vi.fn() },
+        data: { type: 'container-task', image: 'alpine' },
+        needs: [],
+        deps: [],
+        requiredBy: [],
+    };
+}
+describe('usingContainer', () => {
+    it('pauses the container on success when stateKey is set', async () => {
+        const created = makeContainer('new-cid');
+        const { docker } = makeDocker(created);
+        const item = makeItem('task-1');
+        await (0, using_container_1.usingContainer)(docker, item, {}, 'state-A', async () => true);
+        expect(created.pause).toHaveBeenCalledTimes(1);
+        expect(created.remove).not.toHaveBeenCalled();
+    });
+    it('removes containers with a different stateKey and keeps the current one', async () => {
+        const created = makeContainer('new-cid');
+        const stale = { Id: 'old-cid', Labels: { 'hammerkit-state': 'state-B' } };
+        const same = { Id: 'new-cid', Labels: { 'hammerkit-state': 'state-A' } };
+        const { docker, containersById } = makeDocker(created, [stale, same]);
+        const item = makeItem('task-1');
+        await (0, using_container_1.usingContainer)(docker, item, {}, 'state-A', async () => true);
+        expect(containersById['old-cid'].remove).toHaveBeenCalledTimes(1);
+        expect(created.remove).not.toHaveBeenCalled();
+    });
+    it('removes the container when the callback returns false (cache miss on failure)', async () => {
+        const created = makeContainer('new-cid');
+        const { docker } = makeDocker(created);
+        const item = makeItem('task-1');
+        await (0, using_container_1.usingContainer)(docker, item, {}, 'state-A', async () => false);
+        expect(created.pause).not.toHaveBeenCalled();
+        expect(created.remove).toHaveBeenCalledTimes(1);
+    });
+    it('removes the container when the callback throws', async () => {
+        const created = makeContainer('new-cid');
+        const { docker } = makeDocker(created);
+        const item = makeItem('task-1');
+        await expect((0, using_container_1.usingContainer)(docker, item, {}, 'state-A', async () => {
+            throw new Error('boom');
+        })).rejects.toThrow('boom');
+        expect(created.pause).not.toHaveBeenCalled();
+        expect(created.remove).toHaveBeenCalledTimes(1);
+    });
+    it('always removes the container when no stateKey is given', async () => {
+        const created = makeContainer('new-cid');
+        const { docker } = makeDocker(created);
+        const item = makeItem('task-1');
+        await (0, using_container_1.usingContainer)(docker, item, {}, null, async () => true);
+        expect(created.pause).not.toHaveBeenCalled();
+        expect(created.remove).toHaveBeenCalledTimes(1);
+    });
+    it('propagates the callback return value', async () => {
+        const created = makeContainer('new-cid');
+        const { docker } = makeDocker(created);
+        const item = makeItem('task-1');
+        const result = await (0, using_container_1.usingContainer)(docker, item, {}, null, async () => 'payload');
+        expect(result).toBe('payload');
+    });
+});
+//# sourceMappingURL=using-container.spec.js.map

package/dist/environment/merge-environment-variables.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeEnvironmentVariables = void 0;
+function mergeEnvironmentVariables(base, extension) {
+    const result = {};
+    for (const [key, value] of Object.entries(base || {})) {
+        result[key] = `${value}`;
+    }
+    if (!extension) {
+        return result;
+    }
+    for (const key of Object.keys(extension)) {
+        const value = extension[key];
+        if (!result[key] && value) {
+            result[key] = `${value}`;
+        }
+    }
+    return result;
+}
+exports.mergeEnvironmentVariables = mergeEnvironmentVariables;
+//# sourceMappingURL=merge-environment-variables.js.map

package/dist/environment/merge-environment-variables.spec.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const merge_environment_variables_1 = require("./merge-environment-variables");
+describe('mergeEnvironmentVariables', () => {
+    it('copies the base map and stringifies values', () => {
+        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)({ A: 'one', B: 2 }, null)).toEqual({ A: 'one', B: '2' });
+    });
+    it('returns an empty map when both inputs are nullish', () => {
+        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)(null, undefined)).toEqual({});
+    });
+    it('adds extension keys that the base does not define', () => {
+        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)({ A: '1' }, { B: '2' })).toEqual({ A: '1', B: '2' });
+    });
+    it('keeps the base value when both maps define the same key (base wins)', () => {
+        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)({ A: 'base' }, { A: 'override' })).toEqual({ A: 'base' });
+    });
+    it('drops falsy extension values', () => {
+        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)({}, { A: '', B: 0 })).toEqual({});
+    });
+    it('handles an undefined base with an extension', () => {
+        expect((0, merge_environment_variables_1.mergeEnvironmentVariables)(undefined, { A: '1' })).toEqual({ A: '1' });
+    });
+});
+//# sourceMappingURL=merge-environment-variables.spec.js.map

package/dist/environment/replace-env-variables.js

@@ -1,21 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceEnvVariables = void 0;
-function replaceEnvVariables(envs, processEnv) {
-    const result = { ...envs };
-    for (const key of Object.keys(result)) {
-        const value = result[key];
+exports.getEnvironmentVariables = exports.buildEnvironmentVariables = void 0;
+function buildEnvironmentVariables(envs, environment, context) {
+    const replacements = [];
+    const variables = {};
+    for (const [key, value] of Object.entries(envs)) {
         if (value.startsWith('$')) {
-            const processEnvValue = processEnv[value.substr(1)];
-            if (processEnvValue) {
-                result[key] = processEnvValue;
+            const name = value.substring(1);
+            let nameValue = environment.processEnvs[name] ?? null;
+            if (!nameValue) {
+                for (const envFile of Object.values(context.envFiles)) {
+                    nameValue = envFile[name] ?? null;
+                    if (nameValue) {
+                        break;
+                    }
+                }
+            }
+            if (nameValue) {
+                replacements.push({
+                    key,
+                    name,
+                    available: true,
+                    value: nameValue,
+                });
             }
             else {
-                throw new Error(`missing env ${value}`);
+                replacements.push({
+                    key,
+                    name,
+                    available: false,
+                    value: null,
+                });
             }
         }
+        else {
+            variables[key] = value;
+        }
+    }
+    return { variables, replacements };
+}
+exports.buildEnvironmentVariables = buildEnvironmentVariables;
+function getEnvironmentVariables(envs) {
+    const result = { ...envs.variables };
+    for (const replacement of envs.replacements) {
+        if (!replacement.available) {
+            throw new Error(`missing environment variable ${replacement.name}`);
+        }
+        result[replacement.key] = replacement.value;
     }
     return result;
 }
-exports.replaceEnvVariables = replaceEnvVariables;
+exports.getEnvironmentVariables = getEnvironmentVariables;
 //# sourceMappingURL=replace-env-variables.js.map

package/dist/environment/replace-env-variables.spec.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const replace_env_variables_1 = require("./replace-env-variables");
+function env(processEnvs) {
+    return { processEnvs };
+}
+function ctx(envFiles) {
+    return { envFiles };
+}
+describe('replace-env-variables', () => {
+    describe('buildEnvironmentVariables', () => {
+        it('keeps literal values as variables', () => {
+            const result = (0, replace_env_variables_1.buildEnvironmentVariables)({ NODE_ENV: 'production' }, env({}), ctx({}));
+            expect(result.variables).toEqual({ NODE_ENV: 'production' });
+            expect(result.replacements).toEqual([]);
+        });
+        it('resolves $NAME references from processEnvs', () => {
+            const result = (0, replace_env_variables_1.buildEnvironmentVariables)({ TOKEN: '$SECRET' }, env({ SECRET: 'abc' }), ctx({}));
+            expect(result.variables).toEqual({});
+            expect(result.replacements).toEqual([{ key: 'TOKEN', name: 'SECRET', available: true, value: 'abc' }]);
+        });
+        it('falls back to env files when not in processEnvs', () => {
+            const result = (0, replace_env_variables_1.buildEnvironmentVariables)({ TOKEN: '$SECRET' }, env({}), ctx({ '/proj': { SECRET: 'from-file' } }));
+            expect(result.replacements).toEqual([{ key: 'TOKEN', name: 'SECRET', available: true, value: 'from-file' }]);
+        });
+        it('marks unresolved references as unavailable', () => {
+            const result = (0, replace_env_variables_1.buildEnvironmentVariables)({ TOKEN: '$MISSING' }, env({}), ctx({}));
+            expect(result.replacements).toEqual([{ key: 'TOKEN', name: 'MISSING', available: false, value: null }]);
+        });
+    });
+    describe('getEnvironmentVariables', () => {
+        it('merges variables with resolved replacements', () => {
+            const result = (0, replace_env_variables_1.getEnvironmentVariables)({
+                variables: { NODE_ENV: 'production' },
+                replacements: [{ key: 'TOKEN', name: 'SECRET', available: true, value: 'abc' }],
+            });
+            expect(result).toEqual({ NODE_ENV: 'production', TOKEN: 'abc' });
+        });
+        it('throws when a replacement is unavailable', () => {
+            expect(() => (0, replace_env_variables_1.getEnvironmentVariables)({
+                variables: {},
+                replacements: [{ key: 'TOKEN', name: 'SECRET', available: false, value: null }],
+            })).toThrow('missing environment variable SECRET');
+        });
+    });
+});
+//# sourceMappingURL=replace-env-variables.spec.js.map

package/dist/executer/abort.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const abort_1 = require("./abort");
+describe('checkForAbort', () => {
+    it('throws AbortError when the signal is already aborted', () => {
+        const ctrl = new AbortController();
+        ctrl.abort();
+        expect(() => (0, abort_1.checkForAbort)(ctrl.signal)).toThrow(abort_1.AbortError);
+    });
+    it('does nothing when the signal is live', () => {
+        const ctrl = new AbortController();
+        expect(() => (0, abort_1.checkForAbort)(ctrl.signal)).not.toThrow();
+    });
+    it('AbortError extends Error', () => {
+        expect(new abort_1.AbortError()).toBeInstanceOf(Error);
+    });
+});
+//# sourceMappingURL=abort.spec.js.map

package/dist/executer/await-completed-dependencies.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awaitRunningNeeds = exports.awaitRunningNeed = exports.awaitCompleted = exports.awaitCompletedDependencies = exports.awaitNoRequirements = exports.awaitRequirement = void 0;
+const work_item_1 = require("../planner/work-item");
+const state_resolver_1 = require("./state-resolver");
+async function awaitRequirement(svc, abort) {
+    await Promise.race(svc.requiredBy.map((required) => {
+        if ((0, work_item_1.isWorkTaskItem)(required)) {
+            return (0, state_resolver_1.awaitState)('await-requirement', required.state, (state) => state.type === 'ready', abort);
+        }
+        else {
+            return (0, state_resolver_1.awaitState)('await-requirement', required.state, (state) => state.type === 'ready', abort);
+        }
+    }));
+}
+exports.awaitRequirement = awaitRequirement;
+async function awaitNoRequirements(svc, abort) {
+    await Promise.all(svc.requiredBy.map((required) => {
+        if ((0, work_item_1.isWorkTaskItem)(required)) {
+            return (0, state_resolver_1.awaitState)('await-no-requirement', required.state, (state) => state.type === 'completed' || state.type === 'error' || state.type === 'crash' || state.type === 'canceled', abort);
+        }
+        else {
+            return (0, state_resolver_1.awaitState)('await-no-requirement', required.state, (state) => state.type === 'end' || state.type === 'error' || state.type === 'canceled', abort);
+        }
+    }));
+}
+exports.awaitNoRequirements = awaitNoRequirements;
+async function awaitCompletedDependencies(work, deps, abort) {
+    for (const dep of deps) {
+        work.status.write('debug', `await completion of ${dep.name} with state ${dep.state.current.type}`);
+        await awaitCompleted(work, dep, abort);
+    }
+}
+exports.awaitCompletedDependencies = awaitCompletedDependencies;
+function awaitCompleted(work, dep, abort) {
+    return (0, state_resolver_1.isState)('await-completed-' + work.name, dep.state, isCompleted, abort);
+}
+exports.awaitCompleted = awaitCompleted;
+function awaitRunningNeed(work, dep, abort) {
+    return (0, state_resolver_1.isState)('await-running-need-' + work.name, dep.state, isRunning, abort);
+}
+exports.awaitRunningNeed = awaitRunningNeed;
+async function awaitRunningNeeds(work, needs, abort) {
+    for (const need of needs) {
+        work.status.write('debug', 'await need ' + need.name);
+        await awaitRunningNeed(work, need, abort);
+    }
+}
+exports.awaitRunningNeeds = awaitRunningNeeds;
+function isCompleted(val) {
+    return val.type === 'completed';
+}
+function isRunning(val) {
+    return val.type === 'running';
+}
+//# sourceMappingURL=await-completed-dependencies.js.map

package/dist/executer/cache-metadata.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeCacheMetadata = void 0;
+const get_cache_directory_1 = require("../optimizer/get-cache-directory");
+async function writeCacheMetadata(environment, taskId, stats, description) {
+    await environment.file.createDirectory((0, get_cache_directory_1.getCacheDirectory)(taskId));
+    await environment.file.writeFile((0, get_cache_directory_1.getCacheStatsFile)(taskId), JSON.stringify(stats));
+    await environment.file.writeFile((0, get_cache_directory_1.getCacheDescriptionFile)(taskId), JSON.stringify(description));
+}
+exports.writeCacheMetadata = writeCacheMetadata;
+//# sourceMappingURL=cache-metadata.js.map

package/dist/executer/check-readiness.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkReadiness = void 0;
 const execute_docker_1 = require("./execute-docker");
 async function checkReadiness(status, healthCheck, environment, container, abort) {
-    const result = await (0, execute_docker_1.execCommand)(status, environment, container, undefined, healthCheck.cmd.split(' '), null, 2000, abort);
+    const result = await (0, execute_docker_1.execCommand)(status, environment, container, undefined, [healthCheck.cmd.parsed.command, ...healthCheck.cmd.parsed.args], null, 2000, abort);
     if (result.type === 'timeout') {
         return false;
     }

package/dist/{planner/work-node-port.js → executer/container-bind.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=work-node-port.js.map
+//# sourceMappingURL=container-bind.js.map