hammerkit 1.4.0 → 1.5.0-alpha.0

package/dist/log.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.showCursor = exports.hideCursor = exports.writeWorkTreeStatus = exports.formatDate = exports.getNodeName = exports.getNodeNameLength = exports.printWorkTreeResult = exports.isVerbose = exports.consoleContext = exports.getLogLevel = exports.getLogs = void 0;
+exports.showCursor = exports.hideCursor = exports.writeWorkTreeStatus = exports.formatDate = exports.writeNodeLogToConsole = exports.getNodeName = exports.getNodeNameLengthForWorkTree = exports.getNodeNameLength = exports.printTitle = exports.printItem = exports.printProperty = exports.getNodeNameLengthForSchedulerState = exports.printWorkTreeResult = exports.getType = exports.isVerbose = exports.consoleContext = exports.getErrorMessage = exports.getLogLevel = exports.getLogs = void 0;
 const readline_1 = require("readline");
 const plan_work_nodes_1 = require("./planner/utils/plan-work-nodes");
 const colors_1 = __importDefault(require("colors"));
+const fail_never_1 = require("./utils/fail-never");
 function getLogs(chunk) {
     return chunk
         .toString()
@@ -27,44 +28,88 @@ function getLogLevel(level) {
     }
 }
 exports.getLogLevel = getLogLevel;
+function getErrorMessage(e) {
+    if (e instanceof Error) {
+        return e.message;
+    }
+    else if (typeof e === 'string') {
+        return e;
+    }
+    else {
+        return `unknown error ${e}`;
+    }
+}
+exports.getErrorMessage = getErrorMessage;
 function consoleContext() {
     return {
         debug(message) {
-            process.stdout.write(`${getLogLevel('debug')}: ${message}\n`);
+            process.stdout.write(`${formatDate(new Date())} ${getType('cli')} ${getLogLevel('debug')}: ${message}\n`);
         },
         error(message) {
-            process.stdout.write(`${getLogLevel('error')}: ${message}\n`);
+            process.stdout.write(`${formatDate(new Date())} ${getType('cli')} ${getLogLevel('error')}: ${message}\n`);
         },
         info(message) {
-            process.stdout.write(`${getLogLevel('info')}: ${message}\n`);
+            process.stdout.write(`${formatDate(new Date())} ${getType('cli')} ${getLogLevel('info')}: ${message}\n`);
         },
         warn(message) {
-            process.stdout.write(`${getLogLevel('warn')}: ${message}\n`);
+            process.stdout.write(`${formatDate(new Date())} ${getType('cli')} ${getLogLevel('warn')}: ${message}\n`);
         },
     };
 }
 exports.consoleContext = consoleContext;
 exports.isVerbose = process.argv.some((a) => a === '--verbose');
-async function printWorkTreeResult(workTree, result, logConsoleOnFail) {
-    const maxNodeNameLength = getNodeNameLength(workTree);
-    if (logConsoleOnFail && (!result.success || exports.isVerbose)) {
-        for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-            if (node.status.state.type === 'failed' || exports.isVerbose) {
-                const logs = await node.status.console.read();
-                for (const log of logs) {
-                    if (log.level === 'debug' && !exports.isVerbose) {
-                        continue;
-                    }
-                    process.stdout.write(`${colors_1.default.grey('task:')} ${getNodeName(node, maxNodeNameLength)} ${formatDate(log.date)} ${getLogLevel(log.level)}: ${log.message}\n`);
-                }
-                process.stdout.write('-----------------\n');
+const typeLength = ['service', 'task', 'cli']
+    .map((s) => s.length)
+    .reduce((max, current) => (max > current ? max : current), 0);
+function getType(type) {
+    return colors_1.default.grey(getNodeName(type, typeLength) + ':');
+}
+exports.getType = getType;
+async function printWorkTreeResult(schedulerState, env) {
+    const maxNodeNameLength = getNodeNameLengthForSchedulerState(schedulerState);
+    for (const log of env.status.read()) {
+        if (exports.isVerbose || (log.type === 'status' && log.level === 'error')) {
+            process.stdout.write(`${formatDate(log.date)} ${getType(log.context.type)} ${getNodeName(log.context.name, maxNodeNameLength)} - ${colors_1.default.white(log.message)}\n`);
+        }
+    }
+    for (const state of (0, plan_work_nodes_1.iterateWorkServices)(schedulerState.service)) {
+        if (state.type === 'end' && state.reason === 'crash') {
+            const message = `${getType('service')} ${getNodeName(state.service.name, maxNodeNameLength)}`;
+            for (const log of env.status.service(state.service).logs()) {
+                process.stdout.write(`${formatDate(log.date)} ${message} - ${log.console}: ${log.message}\n`);
+            }
+        }
+    }
+    for (const state of (0, plan_work_nodes_1.iterateWorkNodes)(schedulerState.node)) {
+        if (state.type === 'error' || state.type === 'crash') {
+            const message = `${getType('task')} ${getNodeName(state.node.name, maxNodeNameLength)}`;
+            for (const log of env.status.task(state.node).logs()) {
+                process.stdout.write(`${formatDate(log.date)} ${message} - ${log.console}: ${log.message}\n`);
             }
         }
     }
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        let message = `${colors_1.default.grey('task:')} ${getNodeName(node, maxNodeNameLength)} - ${getStateText(node.status.state)}`;
-        if (node.status.state.type === 'completed') {
-            message += ` in ${node.status.state.duration}ms`;
+    for (const state of (0, plan_work_nodes_1.iterateWorkServices)(schedulerState.service)) {
+        let message = `${formatDate(new Date())} ${getType('service')} ${getNodeName(state.service.name, maxNodeNameLength)} - ${getStateText(state)}`;
+        if (state.type === 'end') {
+            if (state.reason === 'crash') {
+                message += ` crashed`;
+            }
+            process.stdout.write(`${message}\n`);
+        }
+    }
+    for (const state of (0, plan_work_nodes_1.iterateWorkNodes)(schedulerState.node)) {
+        let message = `${formatDate(new Date())} ${getType('task')} ${getNodeName(state.node.name, maxNodeNameLength)} - ${getStateText(state)}`;
+        if (state.type === 'completed') {
+            message += ` in ${state.duration}ms`;
+            if (state.cached) {
+                message += ' [CACHED]';
+            }
+        }
+        if (state.type === 'crash') {
+            message += ` exited with ${state.exitCode}`;
+        }
+        if (state.type === 'error') {
+            message += ` with message ${state.errorMessage}`;
         }
         process.stdout.write(`${message}\n`);
     }
@@ -75,40 +120,90 @@ function getStateText(state) {
     if (state.type === 'running') {
         return colors_1.default.blue(state.type);
     }
-    else if (state.type === 'pending') {
+    else if (state.type === 'pending' || state.type === 'starting') {
         return colors_1.default.yellow(state.type);
     }
     else if (state.type === 'completed') {
         return colors_1.default.green(state.type);
     }
-    else if (state.type === 'failed') {
+    else if (state.type === 'crash') {
         return colors_1.default.red(state.type);
     }
-    else if (state.type === 'aborted') {
+    else if (state.type === 'error') {
         return colors_1.default.red(state.type);
     }
-    else if (state.type === 'cancel') {
+    else if (state.type === 'end') {
         return colors_1.default.bgRed(state.type);
     }
+    else if (state.type === 'canceled') {
+        return colors_1.default.bgRed(state.type);
+    }
+    else if (state.type === 'ready') {
+        return colors_1.default.blue(state.type);
+    }
     else {
-        //TODO fail never
-        return '';
+        (0, fail_never_1.failNever)(state, 'unknown node state');
+    }
+}
+function getNodeNameLengthForSchedulerState(schedulerState) {
+    function* Names() {
+        for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(schedulerState.node)) {
+            yield node.node.name;
+        }
+        for (const service of (0, plan_work_nodes_1.iterateWorkServices)(schedulerState.service)) {
+            yield service.service.name;
+        }
     }
+    return getNodeNameLength(Names);
+}
+exports.getNodeNameLengthForSchedulerState = getNodeNameLengthForSchedulerState;
+function printProperty(name, value) {
+    process.stdout.write(`   ${colors_1.default.grey(`${name}:`)} ${value}\n`);
 }
-function getNodeNameLength(workTree) {
+exports.printProperty = printProperty;
+function printItem(item) {
+    process.stdout.write(`• ${item.name}${item.description ? `: ${colors_1.default.white(item.description)}` : ''}\n`);
+}
+exports.printItem = printItem;
+function printTitle(name) {
+    process.stdout.write(`${colors_1.default.bgWhite(name + ':\n')}`);
+}
+exports.printTitle = printTitle;
+function getNodeNameLength(names) {
     let maxNodeNameLength = 0;
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        if (node.name.length > maxNodeNameLength) {
-            maxNodeNameLength = node.name.length;
+    for (const name of names()) {
+        if (name.length > maxNodeNameLength) {
+            maxNodeNameLength = name.length;
         }
     }
     return maxNodeNameLength;
 }
 exports.getNodeNameLength = getNodeNameLength;
-function getNodeName(node, maxNodeNameLength) {
-    return colors_1.default.white(node.name) + ' '.repeat(maxNodeNameLength - node.name.length);
+function getNodeNameLengthForWorkTree(nodes, services) {
+    function* Names() {
+        for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(nodes)) {
+            yield node.node.name;
+        }
+        for (const service of (0, plan_work_nodes_1.iterateWorkServices)(services)) {
+            yield service.service.name;
+        }
+    }
+    return getNodeNameLength(Names);
+}
+exports.getNodeNameLengthForWorkTree = getNodeNameLengthForWorkTree;
+function getNodeName(name, maxNodeNameLength) {
+    return colors_1.default.white(name) + ' '.repeat(Math.max(0, maxNodeNameLength - name.length));
 }
 exports.getNodeName = getNodeName;
+function writeNodeLogToConsole(log, maxNodeNameLength) {
+    const content = log.type === 'console'
+        ? log.console === 'stdout'
+            ? colors_1.default.white(log.message)
+            : colors_1.default.red(log.message)
+        : `${getLogLevel(log.level)} - ${log.message}`;
+    process.stdout.write(`${formatDate(log.date)} ${colors_1.default.grey(log.context.type + ':')} ${getNodeName(log.context.name, maxNodeNameLength)} - ${log.date.toLocaleTimeString()} - ${content}\n`);
+}
+exports.writeNodeLogToConsole = writeNodeLogToConsole;
 function formatDate(date) {
     return colors_1.default.grey(`[${date.getFullYear()}-${(date.getMonth() + 1).toString().padStart(2, '0')}-${date
         .getDay()
@@ -122,34 +217,81 @@ function formatDate(date) {
         .padStart(3, '0')}]`);
 }
 exports.formatDate = formatDate;
-function writeWorkTreeStatus(workTree, ticker) {
-    readline_1.clearScreenDown(process.stdout);
-    const maxNodeNameLength = getNodeNameLength(workTree);
+function writeWorkTreeStatus(schedulerState, env, ticker) {
+    (0, readline_1.clearScreenDown)(process.stdout);
+    const maxNodeNameLength = getNodeNameLengthForSchedulerState(schedulerState);
     let count = 0;
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        let message = `${colors_1.default.grey('task:')} ${getNodeName(node, maxNodeNameLength)} - ${getStateText(node.status.state)}`;
-        if (node.status.state.type === 'pending') {
-            const totalDepCount = node.deps.length;
-            const completedDepCount = totalDepCount - Object.keys(node.status.state.pendingDependencies).length;
+    for (const state of (0, plan_work_nodes_1.iterateWorkServices)(schedulerState.service)) {
+        let message = `${getType('service')} ${getNodeName(state.service.name, maxNodeNameLength)} - ${getStateText(state)}`;
+        const currentMessage = env.status.service(state.service).current();
+        if (currentMessage) {
+            message += ` ${currentMessage.message}`;
+        }
+        count += printWithTruncate(message);
+    }
+    for (const state of (0, plan_work_nodes_1.iterateWorkNodes)(schedulerState.node)) {
+        let message = `${getType('task')} ${getNodeName(state.node.name, maxNodeNameLength)} - ${getStateText(state)}`;
+        if (state.type === 'pending') {
+            const totalDepCount = state.node.deps.length;
+            const totalServiceCount = state.node.needs.length;
+            const completedDepCount = state.node.deps.filter((d) => schedulerState.node[d.id]?.type === 'completed').length;
+            const runningServiceCount = state.node.needs.filter((n) => schedulerState.service[n.id]?.type === 'ready').length;
             if (totalDepCount > 0 && completedDepCount !== totalDepCount) {
                 message += ` | ${colors_1.default.grey(` awaiting dependencies (${completedDepCount}/${totalDepCount})`)}`;
             }
+            if (totalServiceCount > 0 && runningServiceCount !== totalServiceCount) {
+                message += ` | ${colors_1.default.grey(` awaiting service (${runningServiceCount}/${totalServiceCount})`)}`;
+            }
+        }
+        if (state.type === 'starting' || state.type === 'ready') {
+            message += ` | ${spinner[ticker % spinner.length]}`;
+            const currentMessage = env.status.task(state.node).current();
+            if (currentMessage) {
+                message += ` ${currentMessage.message}`;
+            }
         }
-        if (node.status.state.type === 'running') {
+        else if (state.type === 'running') {
             message += ` | ${spinner[ticker % spinner.length]}`;
-            if (node.status.console.current) {
-                message += ` ${node.status.console.current.message}`;
+            const currentMessage = env.status.task(state.node).currentLog();
+            if (currentMessage) {
+                message += ` ${currentMessage.message}`;
             }
         }
-        else if (node.status.state.type === 'completed') {
-            message += ` in ${node.status.state.duration}ms`;
+        else if (state.type === 'completed') {
+            message += ` in ${state.duration}ms`;
+            if (state.cached) {
+                message += ' [CACHED]';
+            }
         }
-        process.stdout.write(`${message}\n`);
-        count++;
+        else if (state.type === 'error') {
+            message += ` ${state.errorMessage}`;
+        }
+        count += printWithTruncate(message);
     }
-    readline_1.moveCursor(process.stdout, 0, -1 * count);
+    (0, readline_1.moveCursor)(process.stdout, 0, -1 * count);
 }
 exports.writeWorkTreeStatus = writeWorkTreeStatus;
+function countChar(message, char) {
+    let result = 0;
+    for (let i = 0; i < message.length; i++) {
+        if (message[i] === char) {
+            result++;
+        }
+    }
+    return result;
+}
+function printWithTruncate(message) {
+    let lineCount = 0;
+    let index = 0;
+    do {
+        const newLineCount = countChar(message, '\n');
+        process.stdout.write(`${message.substr(index, process.stdout.columns)}\n`);
+        index += process.stdout.columns;
+        lineCount++;
+        lineCount += newLineCount;
+    } while (index < message.length);
+    return lineCount;
+}
 function hideCursor() {
     process.stdout.write('\x1B[?25l');
 }

package/dist/logging/grouped-logger.js

@@ -2,26 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupedLogger = void 0;
 const log_1 = require("../log");
-const message_to_console_1 = require("./message-to-console");
-function groupedLogger() {
-    let maxNodeNameLength = 0;
-    return {
-        start(executionContext, workTree) {
-            maxNodeNameLength = log_1.getNodeNameLength(workTree);
-            executionContext.events.on(async (evt) => {
-                if (evt.newState.type === 'completed' || evt.newState.type === 'failed' || evt.newState.type === 'aborted') {
-                    const node = workTree.nodes[evt.nodeId];
-                    for (const log of await node.status.console.read()) {
-                        message_to_console_1.logMessageToConsole(node, log, maxNodeNameLength);
-                    }
+const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
+function groupedLogger(state, env) {
+    const maxNodeNameLength = (0, log_1.getNodeNameLengthForWorkTree)(state.current.node, state.current.service);
+    const completedNodes = [];
+    const completedServices = [];
+    state.on((currentState) => {
+        for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(currentState.node)) {
+            if (completedNodes.indexOf(node.node.id) >= 0) {
+                continue;
+            }
+            if (node.type === 'crash' || node.type === 'error' || node.type === 'completed') {
+                completedNodes.push(node.node.id);
+                for (const log of env.status.task(node.node).read()) {
+                    (0, log_1.writeNodeLogToConsole)(log, maxNodeNameLength);
                 }
-            });
-        },
-        async finish(workTree, result) {
-            await log_1.printWorkTreeResult(workTree, result, false);
-        },
-        abort(e) {
-            process.stderr.write(`${e.message}\n`);
+            }
+        }
+        for (const service of (0, plan_work_nodes_1.iterateWorkServices)(currentState.service)) {
+            if (completedServices.indexOf(service.service.id) >= 0) {
+                continue;
+            }
+            if (service.type === 'end') {
+                completedServices.push(service.service.id);
+                for (const log of env.status.service(service.service).read()) {
+                    (0, log_1.writeNodeLogToConsole)(log, maxNodeNameLength);
+                }
+            }
+        }
+    });
+    return {
+        async complete(evt, env) {
+            await (0, log_1.printWorkTreeResult)(evt.state, env);
         },
     };
 }

package/dist/logging/interactive-logger.js

@@ -3,33 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.interactiveLogger = void 0;
 const log_1 = require("../log");
 const readline_1 = require("readline");
-function interactiveLogger() {
+function interactiveLogger(state, env) {
     let running = true;
     let count = 0;
+    const tickerFn = () => {
+        if (!running) {
+            return;
+        }
+        count++;
+        (0, log_1.writeWorkTreeStatus)(state.current, env, count);
+        if (running) {
+            setTimeout(tickerFn, 100);
+        }
+    };
+    (0, log_1.hideCursor)();
+    tickerFn();
+    state.on((currentState) => {
+        (0, log_1.writeWorkTreeStatus)(currentState, env, count);
+    });
     return {
-        start(executionContext, workTree) {
-            log_1.hideCursor();
-            log_1.writeWorkTreeStatus(workTree, count);
-            const tickerFn = () => {
-                count++;
-                log_1.writeWorkTreeStatus(workTree, count);
-                if (running) {
-                    setTimeout(tickerFn, 100);
-                }
-            };
-            tickerFn();
-            executionContext.events.on(({ workTree }) => {
-                log_1.writeWorkTreeStatus(workTree, count);
-            });
-        },
-        async finish(workTree, result) {
+        async complete(evt, env) {
             running = false;
-            readline_1.clearScreenDown(process.stdout);
-            await log_1.printWorkTreeResult(workTree, result, true);
-            log_1.showCursor();
-        },
-        abort(e) {
-            process.stderr.write(`${e.message}\n`);
+            (0, readline_1.clearScreenDown)(process.stdout);
+            await (0, log_1.printWorkTreeResult)(evt.state, env);
+            (0, log_1.showCursor)();
         },
     };
 }

package/dist/logging/live-logger.js

@@ -2,24 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.liveLogger = void 0;
 const log_1 = require("../log");
-const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
-const message_to_console_1 = require("./message-to-console");
-function liveLogger() {
-    let maxNodeNameLength = 0;
+function liveLogger(state, env) {
+    const maxNodeNameLength = (0, log_1.getNodeNameLengthForWorkTree)(state.current.node, state.current.service);
+    env.status.on((log) => {
+        (0, log_1.writeNodeLogToConsole)(log, maxNodeNameLength);
+    });
     return {
-        start(executionContext, workTree) {
-            maxNodeNameLength = log_1.getNodeNameLength(workTree);
-            for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-                node.status.console.on((log) => {
-                    message_to_console_1.logMessageToConsole(node, log, maxNodeNameLength);
-                });
-            }
-        },
-        async finish(workTree, result) {
-            await log_1.printWorkTreeResult(workTree, result, false);
-        },
-        abort(e) {
-            process.stderr.write(`${e.message}\n`);
+        async complete(evt, env) {
+            await (0, log_1.printWorkTreeResult)(evt.state, env);
         },
     };
 }

package/dist/optimizer/calculate-checksum.js

@@ -4,7 +4,7 @@ exports.calculateChecksum = void 0;
 const crypto_1 = require("crypto");
 async function calculateChecksum(environment, path) {
     const input = await environment.file.read(path);
-    return crypto_1.createHash('sha1').update(input).digest('hex');
+    return (0, crypto_1.createHash)('sha1').update(input).digest('hex');
 }
 exports.calculateChecksum = calculateChecksum;
 //# sourceMappingURL=calculate-checksum.js.map

package/dist/optimizer/get-cache-directory.js

@@ -1,33 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHammerkitDirectory = exports.getCacheStatsFile = exports.getCacheStatsDirectory = exports.getCacheDescriptionFile = exports.getCacheDirectory = void 0;
+exports.getHammerkitDirectory = exports.getCacheStatsFile = exports.getCacheDescriptionFile = exports.getCacheDirectory = void 0;
 const path_1 = require("path");
-const crypto_1 = require("crypto");
 function getCacheDirectory(nodeId) {
-    return path_1.join(getHammerkitDirectory(), 'cache', nodeId);
+    return (0, path_1.join)(getHammerkitDirectory(), 'cache', nodeId);
 }
 exports.getCacheDirectory = getCacheDirectory;
 function getCacheDescriptionFile(nodeId) {
-    return path_1.join(getCacheDirectory(nodeId), 'description.json');
+    return (0, path_1.join)(getCacheDirectory(nodeId), 'description.json');
 }
 exports.getCacheDescriptionFile = getCacheDescriptionFile;
-function getCacheStatsDirectory(nodeId, cwd) {
-    return path_1.join(getCacheDirectory(nodeId), crypto_1.createHash('sha1').update(cwd).digest('hex'));
-}
-exports.getCacheStatsDirectory = getCacheStatsDirectory;
-function getCacheStatsFile(nodeId, cwd) {
-    return path_1.join(getCacheStatsDirectory(nodeId, cwd), 'stats.json');
+function getCacheStatsFile(nodeId) {
+    return (0, path_1.join)(getCacheDirectory(nodeId), 'stats.json');
 }
 exports.getCacheStatsFile = getCacheStatsFile;
 function getHammerkitDirectory() {
     if (process.platform === 'win32') {
-        return path_1.join(process.env.APPDATA, 'hammerkit');
+        return (0, path_1.join)(process.env.APPDATA, 'hammerkit');
     }
     else if (process.platform === 'darwin') {
-        return path_1.join(process.env.HOME, 'Library', 'Application Support', 'hammerkit');
+        return (0, path_1.join)(process.env.HOME, 'Library', 'Application Support', 'hammerkit');
     }
     else {
-        return path_1.join(process.env.HOME, '.hammerkit');
+        return (0, path_1.join)(process.env.HOME, '.hammerkit');
     }
 }
 exports.getHammerkitDirectory = getHammerkitDirectory;

package/dist/optimizer/get-work-node-cache-stats.js

@@ -1,51 +1,98 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasStatsChanged = exports.getWorkNodeCacheStats = void 0;
+exports.getStateKey = exports.getCacheState = exports.getWorkNodeCacheStats = exports.getServiceNodeCacheStats = void 0;
 const calculate_checksum_1 = require("./calculate-checksum");
 const path_1 = require("path");
-async function addWorkNodeCacheStats(result, path, matcher, context) {
+const crypto_1 = require("crypto");
+async function addWorkNodeCacheStats(result, cwd, path, matcher, context) {
+    const exists = await context.file.exists(path);
+    if (!exists) {
+        return;
+    }
     const stats = await context.file.stats(path);
     if (stats.type === 'file') {
         if (matcher(path)) {
-            const checksum = await calculate_checksum_1.calculateChecksum(context, path);
-            result.files[path_1.relative(result.cwd, path)] = { lastModified: stats.lastModified, checksum };
+            const checksum = await (0, calculate_checksum_1.calculateChecksum)(context, path);
+            result.files[(0, path_1.relative)(cwd, path)] = { lastModified: stats.lastModified, checksum };
         }
     }
     else if (stats.type === 'directory') {
         const files = await context.file.listFiles(path);
         for (const file of files) {
-            const subPath = path_1.join(path, file);
+            const subPath = (0, path_1.join)(path, file);
             if (matcher(subPath)) {
-                await addWorkNodeCacheStats(result, path_1.join(path, file), matcher, context);
+                await addWorkNodeCacheStats(result, cwd, (0, path_1.join)(path, file), matcher, context);
             }
         }
     }
 }
+async function addWorkServiceCacheStats(result, path, context) {
+    const exists = await context.file.exists(path);
+    if (!exists) {
+        return;
+    }
+    const stats = await context.file.stats(path);
+    if (stats.type === 'file') {
+        const checksum = await (0, calculate_checksum_1.calculateChecksum)(context, path);
+        result.files[path] = { lastModified: stats.lastModified, checksum };
+    }
+    else if (stats.type === 'directory') {
+        const files = await context.file.listFiles(path);
+        for (const file of files) {
+            await addWorkServiceCacheStats(result, (0, path_1.join)(path, file), context);
+        }
+    }
+}
+async function getServiceNodeCacheStats(cache, environment) {
+    const result = {
+        files: {},
+    };
+    for (const mount of cache.mounts) {
+        await addWorkServiceCacheStats(result, mount.localPath, environment);
+    }
+    return result;
+}
+exports.getServiceNodeCacheStats = getServiceNodeCacheStats;
 async function getWorkNodeCacheStats(cache, environment) {
     const result = {
-        cwd: cache.cwd,
+        created: new Date(),
         files: {},
     };
     for (const src of cache.src) {
-        await addWorkNodeCacheStats(result, src.absolutePath, (file) => src.matcher(file, cache.cwd), environment);
+        await addWorkNodeCacheStats(result, cache.cwd, src.absolutePath, (file) => src.matcher(file, cache.cwd), environment);
     }
     return result;
 }
 exports.getWorkNodeCacheStats = getWorkNodeCacheStats;
-async function hasStatsChanged(node, cache, current, cacheMethod) {
-    let changed = false;
-    for (const key of Object.keys(cache.files)) {
-        if ((cacheMethod === 'checksum' && current.files[key]?.checksum !== cache.files[key].checksum) ||
-            (cacheMethod === 'modify-date' && current.files[key]?.lastModified !== cache.files[key].lastModified)) {
-            node.status.console.write('internal', 'debug', cacheMethod === 'checksum'
-                ? `${key} changed from checksum ${cache.files[key].checksum} to ${current.files[key]?.checksum}`
-                : `${key} changed from last modified ${cache.files[key].lastModified} to ${current.files[key]?.lastModified}`);
-            node.status.console.write('internal', 'debug', `${node.name} can't be skipped because ${key} has been modified`);
-            changed = true;
-            break;
+function getCacheState(status, node, cache, current) {
+    if (cache) {
+        for (const key of Object.keys(cache.files)) {
+            if ((node.caching === 'checksum' && current.files[key]?.checksum !== cache.files[key].checksum) ||
+                (node.caching === 'modify-date' && current.files[key]?.lastModified !== cache.files[key].lastModified)) {
+                status.write('debug', node.caching === 'checksum'
+                    ? `${key} changed from checksum ${cache.files[key].checksum} to ${current.files[key]?.checksum}`
+                    : `${key} changed from last modified ${cache.files[key].lastModified} to ${current.files[key]?.lastModified}`);
+                status.write('debug', `${node.name} can't be skipped because ${key} has been modified`);
+                break;
+            }
+        }
+    }
+    return {
+        stateKey: getStateKey(current, node.caching),
+    };
+}
+exports.getCacheState = getCacheState;
+function getStateKey(stats, cacheMethod) {
+    const contents = [];
+    for (const key of Object.keys(stats.files)) {
+        if (cacheMethod === 'checksum') {
+            contents.push(`${key}:${stats.files[key].checksum}`);
+        }
+        else if (cacheMethod === 'modify-date') {
+            contents.push(`${key}:${stats.files[key].lastModified}`);
         }
     }
-    return changed;
+    return (0, crypto_1.createHash)('md5').update(contents.join(',')).digest('hex');
 }
-exports.hasStatsChanged = hasStatsChanged;
+exports.getStateKey = getStateKey;
 //# sourceMappingURL=get-work-node-cache-stats.js.map