hammerkit 1.4.0 → 1.5.0-alpha.0

package/dist/executer/start-node.js

@@ -0,0 +1,59 @@
+"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) {
+    const cacheState = await (0, enqueue_next_1.checkCacheState)(node.node, state.current.cacheMethod, environment);
+    const currentState = state.current.node[node.node.id];
+    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) {
+    if (!(0, work_service_1.isContainerWorkService)(service)) {
+        state.patchService({
+            type: 'ready',
+            service,
+            stateKey: '', // TODO statekey from kube config
+        });
+        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/state-listener.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=state-listener.js.map

package/dist/executer/state.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.State = void 0;
+class State {
+    constructor(current) {
+        this.current = current;
+        this.listeners = [];
+    }
+    assignState(state, newValue) {
+        const currentKeys = Object.keys(state);
+        const newKeys = Object.keys(newValue);
+        const keysToRemove = currentKeys.filter((k) => newKeys.indexOf(k) === -1);
+        for (const key of keysToRemove) {
+            delete state[key];
+        }
+        for (const key of newKeys) {
+            state[key] = newValue[key];
+        }
+    }
+    resetNode(newState) {
+        const state = this.current.node[newState.node.id];
+        this.assignState(state, newState);
+        this.notifyListeners(this.current);
+        return state;
+    }
+    patchNode(newState, stateKey) {
+        const state = this.current.node[newState.node.id];
+        if (state.stateKey === stateKey) {
+            this.assignState(state, newState);
+            this.notifyListeners(this.current);
+        }
+        return state;
+    }
+    patchService(newState) {
+        this.assignState(this.current.service[newState.service.id], newState);
+        this.notifyListeners(this.current);
+    }
+    on(listener) {
+        this.listeners.push(listener);
+        listener(this.current);
+    }
+    notifyListeners(evt) {
+        for (const listener of this.listeners) {
+            listener(evt);
+        }
+    }
+}
+exports.State = State;
+//# sourceMappingURL=state.js.map

package/dist/executer/states.js

@@ -1,163 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cancelNodes = exports.resetNode = exports.failNode = exports.completeNode = exports.runNode = void 0;
-const plan_work_nodes_1 = require("../planner/utils/plan-work-nodes");
-const abort_event_1 = require("../utils/abort-event");
-function getDuration(state) {
-    if (state.type === 'running') {
-        return new Date().getTime() - state.started.getTime();
-    }
-    return 0;
+exports.getDuration = void 0;
+function getDuration(started) {
+    return new Date().getTime() - started.getTime();
 }
-function runNode(workTree, nodeId, context) {
-    const runningState = {
-        type: 'running',
-        started: new Date(),
-        abortCtrl: new AbortController(),
-    };
-    abort_event_1.listenOnAbort(context.environment.abortCtrl.signal, () => {
-        runningState.abortCtrl.abort();
-    });
-    const currentState = workTree.nodes[nodeId].status.state;
-    workTree.nodes[nodeId].status.state = runningState;
-    context.events.emit({ oldState: currentState, newState: runningState, nodeId, workTree });
-    return runningState.abortCtrl;
-}
-exports.runNode = runNode;
-function completeNode(workTree, nodeId, context) {
-    const node = workTree.nodes[nodeId];
-    const currentState = node.status.state;
-    const completedState = {
-        type: 'completed',
-        ended: new Date(),
-        duration: getDuration(currentState),
-    };
-    node.status.state = completedState;
-    if (!context.watch && !node.status.defer.signal.aborted) {
-        node.status.defer.abort();
-    }
-    context.events.emit({ oldState: currentState, newState: completedState, nodeId, workTree });
-    for (const otherNode of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        if (otherNode.status.state.type !== 'pending') {
-            continue;
-        }
-        const pendingDependencies = otherNode.status.state.pendingDependencies;
-        const dependency = pendingDependencies[node.id];
-        if (!dependency) {
-            continue;
-        }
-        const newState = {
-            type: 'pending',
-            pendingDependencies: Object.keys(pendingDependencies).reduce((map, key) => {
-                if (pendingDependencies[key].status.state.type !== 'completed') {
-                    map[key] = pendingDependencies[key];
-                }
-                return map;
-            }, {}),
-        };
-        const evt = {
-            oldState: otherNode.status.state,
-            nodeId: otherNode.id,
-            workTree,
-            newState,
-        };
-        otherNode.status.state = newState;
-        context.events.emit(evt);
-    }
-}
-exports.completeNode = completeNode;
-function failNode(workTree, nodeId, context, error) {
-    const node = workTree.nodes[nodeId];
-    node.status.console.write('internal', 'error', error.message);
-    const canceledExecution = context.environment.abortCtrl.signal.aborted;
-    const currentState = node.status.state;
-    if (currentState.type === 'running') {
-        const newState = canceledExecution
-            ? { type: 'aborted' }
-            : { type: 'failed', ended: new Date(), duration: getDuration(node.status.state), error };
-        node.status.state = newState;
-        context.events.emit({ nodeId: node.id, workTree, newState, oldState: currentState });
-    }
-    else if (currentState.type === 'cancel') {
-        const newState = canceledExecution ? { type: 'aborted' } : getPendingState(node);
-        node.status.state = newState;
-        context.events.emit({ nodeId: node.id, workTree, newState, oldState: currentState });
-    }
-    if (!canceledExecution && !context.watch) {
-        cancelPendingNodes(workTree, nodeId, context);
-    }
-    if ((canceledExecution || !context.watch) && !node.status.defer.signal.aborted) {
-        node.status.defer.abort();
-    }
-}
-exports.failNode = failNode;
-function getPendingState(node) {
-    return {
-        type: 'pending',
-        pendingDependencies: node.deps.reduce((map, dep) => {
-            if (dep.status.state.type !== 'completed') {
-                map[dep.id] = dep;
-            }
-            return map;
-        }, {}),
-    };
-}
-function resetNode(workTree, nodeId, context) {
-    const node = workTree.nodes[nodeId];
-    const currentState = node.status.state;
-    if (currentState.type === 'running') {
-        const cancelState = { type: 'cancel' };
-        node.status.state = cancelState;
-        currentState.abortCtrl.abort();
-        context.events.emit({ workTree, nodeId, oldState: currentState, newState: cancelState });
-    }
-    else if (currentState.type === 'completed' || currentState.type === 'failed') {
-        const pendingState = getPendingState(node);
-        node.status.state = pendingState;
-        context.events.emit({ workTree, nodeId, oldState: currentState, newState: pendingState });
-    }
-}
-exports.resetNode = resetNode;
-function cancelPendingNodes(workTree, nodeId, context) {
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        if (node.status.state.type !== 'pending') {
-            continue;
-        }
-        if (!node.status.state.pendingDependencies[nodeId]) {
-            continue;
-        }
-        const currentState = node.status.state;
-        if (currentState.type === 'pending') {
-            const cancelState = { type: 'cancel' };
-            node.status.state = cancelState;
-            context.events.emit({ workTree, nodeId, oldState: currentState, newState: cancelState });
-            if (!context.watch) {
-                node.status.defer.abort();
-            }
-            cancelPendingNodes(workTree, node.id, context);
-        }
-    }
-}
-function cancelNodes(workTree, context) {
-    for (const node of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        const currentState = node.status.state;
-        if (currentState.type === 'pending') {
-            const abortState = { type: 'aborted' };
-            node.status.state = abortState;
-            node.status.defer.abort();
-            context.events.emit({ nodeId: node.id, workTree, newState: abortState, oldState: currentState });
-        }
-        else if (currentState.type === 'running') {
-            const cancelState = { type: 'cancel' };
-            node.status.state = cancelState;
-            currentState.abortCtrl.abort();
-            context.events.emit({ workTree, nodeId: node.id, oldState: currentState, newState: cancelState });
-        }
-        else if ((currentState.type === 'completed' || currentState.type === 'failed') &&
-            !node.status.defer.signal.aborted) {
-            node.status.defer.abort();
-        }
-    }
-}
-exports.cancelNodes = cancelNodes;
+exports.getDuration = getDuration;
 //# sourceMappingURL=states.js.map

package/dist/executer/watch-node.js

@@ -0,0 +1,57 @@
+"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,
+            });
+            // TODO set dependants as pending
+        }, 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

package/dist/executer/watch-service.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchService = 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 watchService(service, state, processManager, environment) {
+    return async (abort) => {
+        let currentState = await (0, get_work_node_cache_stats_1.getServiceNodeCacheStats)(service, environment);
+        const status = environment.status.service(service);
+        const debouncer = new debouncer_1.Debouncer(async () => {
+            if (environment.abortCtrl.signal.aborted) {
+                return;
+            }
+            const newStats = await (0, get_work_node_cache_stats_1.getServiceNodeCacheStats)(service, environment);
+            const currentFileState = (0, get_work_node_cache_stats_1.getCacheState)(status, { name: service.name, caching: state.current.cacheMethod }, currentState, newStats);
+            currentState = newStats;
+            const currentServiceState = state.current.service[service.id];
+            if (currentServiceState.stateKey === currentFileState.stateKey) {
+                return;
+            }
+            status.write('debug', `source changed for service ${service.name}, restart process`);
+            state.patchService({
+                type: 'pending',
+                service,
+                stateKey: currentFileState.stateKey,
+            });
+        }, 100);
+        const fileWatchers = [];
+        const mounts = [];
+        for (const mount of service.mounts) {
+            status.write('debug', `watch ${mount.localPath} mount`);
+            const watcher = environment.file.watch(mount.localPath, async (fileName) => {
+                const absoluteFileName = (0, path_1.join)(mount.localPath, fileName);
+                status.write('debug', `source ${absoluteFileName} change for watched service ${service.name}`);
+                debouncer.bounce();
+            });
+            mounts.push(mount.localPath);
+            fileWatchers.push(watcher);
+        }
+        await (0, abort_event_1.waitOnAbort)(abort.signal);
+        debouncer.clear();
+        for (const watcher of fileWatchers) {
+            watcher.close();
+        }
+        return {
+            type: 'service-watch-canceled',
+            service,
+        };
+    };
+}
+exports.watchService = watchService;
+//# sourceMappingURL=watch-service.js.map

package/dist/executer/work-scope.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isContextTaskFilter = exports.emptyWorkLabelScope = void 0;
+function emptyWorkLabelScope() {
+    return { excludeLabels: {}, filterLabels: {} };
+}
+exports.emptyWorkLabelScope = emptyWorkLabelScope;
+const isContextTaskFilter = (target) => 'taskName' in target;
+exports.isContextTaskFilter = isContextTaskFilter;
+//# sourceMappingURL=work-scope.js.map

package/dist/file/get-file-context-mock.spec.js

@@ -3,18 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const get_file_context_mock_1 = require("./get-file-context-mock");
 describe('file/get-file-context-mock', () => {
     it('should create directory', async () => {
-        const ctx = get_file_context_mock_1.getFileContextMock();
+        const ctx = (0, get_file_context_mock_1.getFileContextMock)();
         await ctx.createDirectory('/home/user/repo');
         expect(await ctx.listFiles('/home/user')).toEqual(['repo']);
     });
     it('should list files', async () => {
-        const ctx = get_file_context_mock_1.getFileContextMock();
+        const ctx = (0, get_file_context_mock_1.getFileContextMock)();
         await ctx.createDirectory('/home/user/repo');
         await ctx.writeFile('/home/user/test', 'abc');
         expect(await ctx.listFiles('/home/user')).toEqual(['repo', 'test']);
     });
     it('should emit listener if file below gets changed', async () => {
-        const ctx = get_file_context_mock_1.getFileContextMock();
+        const ctx = (0, get_file_context_mock_1.getFileContextMock)();
         await ctx.createDirectory('/home/user/repo');
         await ctx.writeFile('/home/user/test', 'abc');
         await new Promise((resolve) => {
@@ -27,7 +27,7 @@ describe('file/get-file-context-mock', () => {
         });
     });
     it('should emit listener if directory below gets created', async () => {
-        const ctx = get_file_context_mock_1.getFileContextMock();
+        const ctx = (0, get_file_context_mock_1.getFileContextMock)();
         await ctx.createDirectory('/home/user/repo');
         await new Promise((resolve) => {
             const watch = ctx.watch('/home/user', (fileName) => {
@@ -39,7 +39,7 @@ describe('file/get-file-context-mock', () => {
         });
     });
     it('should not emit listener if directory above gets created', async () => {
-        const ctx = get_file_context_mock_1.getFileContextMock();
+        const ctx = (0, get_file_context_mock_1.getFileContextMock)();
         await ctx.createDirectory('/home/user/repo');
         await new Promise((resolve, reject) => {
             const watch = ctx.watch('/home/user', () => {

package/dist/file/get-file-context.js

@@ -16,11 +16,19 @@ function handleCallback(callback) {
         });
     });
 }
-function getFileContext() {
+function getAbsolutePath(cwd, path) {
+    if ((0, path_1.isAbsolute)(path)) {
+        return path;
+    }
+    else {
+        return (0, path_1.join)(cwd, path);
+    }
+}
+function getFileContext(cwd) {
     return {
         stats(path) {
             return new Promise((resolve, reject) => {
-                fs_1.stat(path, (err, stats) => {
+                (0, fs_1.stat)(getAbsolutePath(cwd, path), (err, stats) => {
                     if (err) {
                         reject(err);
                     }
@@ -39,16 +47,25 @@ function getFileContext() {
             });
         },
         appendFile(path, content) {
-            return handleCallback((cb) => fs_1.appendFile(path, content, cb));
+            return handleCallback((cb) => (0, fs_1.appendFile)(getAbsolutePath(cwd, path), content, cb));
         },
         writeFile(path, content) {
-            return handleCallback((cb) => fs_1.writeFile(path, content, cb));
+            return handleCallback((cb) => (0, fs_1.writeFile)(getAbsolutePath(cwd, path), content, cb));
+        },
+        async writeStream(path, stream) {
+            const writeStream = (0, fs_1.createWriteStream)(path);
+            await new Promise((resolve, reject) => {
+                stream
+                    .pipe(writeStream)
+                    .on('error', (err) => reject(err))
+                    .on('close', () => resolve());
+            });
         },
         listFiles(path) {
-            return handleCallback((cb) => fs_1.readdir(path, cb));
+            return handleCallback((cb) => (0, fs_1.readdir)(getAbsolutePath(cwd, path), cb));
         },
         exists(path) {
-            return handleCallback((cb) => fs_1.stat(path, (err) => {
+            return handleCallback((cb) => (0, fs_1.stat)(getAbsolutePath(cwd, path), (err) => {
                 if (err) {
                     cb(null, false);
                 }
@@ -57,8 +74,11 @@ function getFileContext() {
                 }
             }));
         },
+        readStream(path) {
+            return (0, fs_1.createReadStream)(path);
+        },
         read(path) {
-            return handleCallback((cb) => fs_1.readFile(path, (err, content) => {
+            return handleCallback((cb) => (0, fs_1.readFile)(getAbsolutePath(cwd, path), (err, content) => {
                 if (err) {
                     cb(err, null);
                 }
@@ -68,36 +88,39 @@ function getFileContext() {
             }));
         },
         async copy(source, destination) {
-            const exists = await this.exists(source);
+            const absoluteSource = getAbsolutePath(cwd, source);
+            const absoluteDestination = getAbsolutePath(cwd, destination);
+            const exists = await this.exists(absoluteSource);
             if (!exists) {
                 return;
             }
-            const stats = await this.stats(source);
+            const stats = await this.stats(absoluteSource);
             if (stats.type === 'directory') {
-                await this.createDirectory(destination);
-                for (const child of await this.listFiles(source)) {
-                    await this.copy(path_1.join(source, child), path_1.join(destination, child));
+                await this.createDirectory(absoluteDestination);
+                for (const child of await this.listFiles(absoluteSource)) {
+                    await this.copy((0, path_1.join)(absoluteSource, child), (0, path_1.join)(absoluteDestination, child));
                 }
             }
             else {
-                const destinationDirectory = path_1.dirname(destination);
+                const destinationDirectory = (0, path_1.dirname)(absoluteDestination);
                 const existsDestinationDirectory = await this.exists(destinationDirectory);
                 if (!existsDestinationDirectory) {
                     await this.createDirectory(destinationDirectory);
                 }
-                return handleCallback((cb) => fs_1.copyFile(source, destination, cb));
+                return handleCallback((cb) => (0, fs_1.copyFile)(absoluteSource, absoluteDestination, cb));
             }
         },
         createDirectory(path) {
-            return handleCallback((cb) => fs_1.mkdir(path, { recursive: true }, cb));
+            return handleCallback((cb) => (0, fs_1.mkdir)(getAbsolutePath(cwd, path), { recursive: true }, cb));
         },
         async remove(path) {
-            if (await this.exists(path)) {
-                return handleCallback((cb) => fs_1.rm(path, { recursive: true }, cb));
+            const absolutePath = getAbsolutePath(cwd, path);
+            if (await this.exists(absolutePath)) {
+                return handleCallback((cb) => (0, fs_1.rm)(absolutePath, { recursive: true }, cb));
             }
         },
         watch(path, callback) {
-            const watcher = chokidar_1.watch(path);
+            const watcher = (0, chokidar_1.watch)(getAbsolutePath(cwd, path));
             watcher.on('add', (fileName) => {
                 callback(fileName);
             });

package/dist/file/move-files.js

@@ -19,7 +19,7 @@ async function moveFiles(node, context, folder) {
         if (await context.file.exists(folder.to)) {
             await context.file.remove(folder.to);
         }
-        node.status.console.write('internal', 'debug', `copy ${folder.from} to ${folder.to}`);
+        context.status.task(node).write('debug', `copy ${folder.from} to ${folder.to}`);
         await context.file.copy(folder.from, folder.to);
     }
 }

package/dist/get-work-context.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkScope = void 0;
+const plan_work_tree_1 = require("./planner/utils/plan-work-tree");
+const plan_work_nodes_1 = require("./planner/utils/plan-work-nodes");
+const work_scope_1 = require("./executer/work-scope");
+const replace_env_variables_1 = require("./environment/replace-env-variables");
+const work_service_1 = require("./planner/work-service");
+const work_node_1 = require("./planner/work-node");
+const get_process_env_1 = require("./environment/get-process-env");
+function getWorkScope(buildFile, contextFilter, environment) {
+    const tree = (0, work_scope_1.isContextTaskFilter)(contextFilter)
+        ? (0, plan_work_tree_1.planWorkTree)(buildFile, { taskName: contextFilter.taskName })
+        : (0, plan_work_nodes_1.planWorkNodes)(buildFile, contextFilter);
+    for (const node of (0, plan_work_nodes_1.iterateWorkNodes)(tree.nodes)) {
+        node.envs = (0, replace_env_variables_1.replaceEnvVariables)(node.envs, environment.processEnvs);
+        if (!(0, work_node_1.isContainerWorkNode)(node)) {
+            node.envs = (0, get_process_env_1.extendHostVariables)(node.envs, environment);
+        }
+    }
+    for (const service of (0, plan_work_nodes_1.iterateWorkServices)(tree.services)) {
+        if ((0, work_service_1.isContainerWorkService)(service)) {
+            service.envs = (0, replace_env_variables_1.replaceEnvVariables)(service.envs, environment.processEnvs);
+        }
+    }
+    return tree;
+}
+exports.getWorkScope = getWorkScope;
+//# sourceMappingURL=get-work-context.js.map

package/dist/index.js

@@ -4,17 +4,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const program_1 = require("./program");
 const log_1 = require("./log");
 const get_file_context_1 = require("./file/get-file-context");
+const work_node_status_1 = require("./planner/work-node-status");
+const execute_docker_1 = require("./executer/execute-docker");
 const abortCtrl = new AbortController();
 process.on('SIGINT', function () {
     abortCtrl.abort();
 });
-program_1.getProgram({
+(0, program_1.getProgram)({
     cwd: process.cwd(),
     abortCtrl,
     processEnvs: process.env,
-    file: get_file_context_1.getFileContext(),
-    console: log_1.consoleContext(),
+    file: (0, get_file_context_1.getFileContext)(process.cwd()),
+    console: (0, log_1.consoleContext)(),
+    status: (0, work_node_status_1.statusConsole)(),
+    docker: (0, execute_docker_1.getContainerCli)(),
 }, process.argv).then(({ program, args }) => {
-    program.parse(args);
+    return program.parseAsync(args);
 });
 //# sourceMappingURL=index.js.map