hammerkit 1.4.0-beta.6 → 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,133 +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 defer_1 = require("../utils/defer");
-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(), cancelDefer: new defer_1.Defer() };
-    context.environment.cancelDefer.promise.then(() => {
-        if (!runningState.cancelDefer.isResolved) {
-            runningState.cancelDefer.resolve();
-        }
-    });
-    const currentState = workTree.nodes[nodeId].status.state;
-    workTree.nodes[nodeId].status.state = runningState;
-    context.runningNodes[nodeId] = workTree.nodes[nodeId];
-    context.events.emit({ oldState: currentState, newState: runningState, nodeId, workTree });
-    return runningState.cancelDefer;
-}
-exports.runNode = runNode;
-function completeNode(workTree, nodeId, context, resetCompletedNodes) {
-    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.isResolved) {
-        node.status.defer.resolve();
-    }
-    delete context.runningNodes[node.id];
-    for (const otherNode of plan_work_nodes_1.iterateWorkNodes(workTree.nodes)) {
-        const dependency = otherNode.status.pendingDependencies[node.id];
-        if (dependency) {
-            delete otherNode.status.pendingDependencies[node.id];
-            otherNode.status.completedDependencies[node.id] = dependency;
-        }
-        const completedDepNode = otherNode.status.completedDependencies[node.id];
-        if (resetCompletedNodes && completedDepNode) {
-            resetNode(workTree, otherNode.id, context);
-        }
-    }
-    context.events.emit({ oldState: currentState, newState: completedState, nodeId, workTree });
-}
-exports.completeNode = completeNode;
-function failNode(workTree, nodeId, context, error) {
-    const node = workTree.nodes[nodeId];
-    delete context.runningNodes[nodeId];
-    node.status.console.write('internal', 'error', error.message);
-    const canceledExecution = context.environment.cancelDefer.isResolved;
-    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' } : { type: 'pending' };
-        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.isResolved) {
-        node.status.defer.resolve();
-    }
-}
-exports.failNode = failNode;
-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.cancelDefer.resolve();
-        context.events.emit({ workTree, nodeId, oldState: currentState, newState: cancelState });
-    }
-    else if (currentState.type === 'completed' || currentState.type === 'failed') {
-        const pendingState = { type: 'pending' };
-        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.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.resolve();
-            }
-            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.resolve();
-            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.cancelDefer.resolve();
-            context.events.emit({ workTree, nodeId: node.id, oldState: currentState, newState: cancelState });
-        }
-        else if ((currentState.type === 'completed' || currentState.type === 'failed') && !node.status.defer.isResolved) {
-            node.status.defer.resolve();
-        }
-    }
-}
-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.js

@@ -103,6 +103,7 @@ function getFileContextMock() {
                 }
             }
             notifyChange(parts, path);
+            return path;
         },
         async copy(source, destination) {
             const destinationPath = destination.split(path_1.sep);

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

@@ -1,55 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const get_file_context_mock_1 = require("./get-file-context-mock");
-const defer_1 = require("../utils/defer");
 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');
-        const defer = new defer_1.Defer();
-        const watch = ctx.watch('/home/user', (fileName) => {
-            expect(fileName).toEqual('/home/user/test');
-            defer.resolve();
+        await new Promise((resolve) => {
+            const watch = ctx.watch('/home/user', (fileName) => {
+                expect(fileName).toEqual('/home/user/test');
+                watch.close();
+                resolve();
+            });
+            ctx.appendFile('/home/user/test', 'def');
         });
-        await ctx.appendFile('/home/user/test', 'def');
-        await defer.promise;
-        watch.close();
     });
     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');
-        const defer = new defer_1.Defer();
-        const watch = ctx.watch('/home/user', (fileName) => {
-            expect(fileName).toEqual('/home/user/repo/test');
-            defer.resolve();
+        await new Promise((resolve) => {
+            const watch = ctx.watch('/home/user', (fileName) => {
+                expect(fileName).toEqual('/home/user/repo/test');
+                watch.close();
+                resolve();
+            });
+            ctx.createDirectory('/home/user/repo/test');
         });
-        await ctx.createDirectory('/home/user/repo/test');
-        await defer.promise;
-        watch.close();
     });
     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');
-        const defer = new defer_1.Defer();
-        const watch = ctx.watch('/home/user', () => {
-            defer.reject();
+        await new Promise((resolve, reject) => {
+            const watch = ctx.watch('/home/user', () => {
+                watch.close();
+                reject();
+            });
+            ctx.createDirectory('/home/test').then(() => {
+                watch.close();
+                resolve();
+            });
         });
-        await ctx.createDirectory('/home/test');
-        defer.resolve();
-        await defer.promise;
-        watch.close();
     });
 });
 //# sourceMappingURL=get-file-context-mock.spec.js.map

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

@@ -4,113 +4,123 @@ exports.getFileContext = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const chokidar_1 = require("chokidar");
-const defer_1 = require("../utils/defer");
-function handleCallback(defer) {
-    return (err, value) => {
-        if (err) {
-            defer.reject(err);
-        }
-        else {
-            defer.resolve(value);
-        }
-    };
+function handleCallback(callback) {
+    return new Promise((resolve, reject) => {
+        callback((err, value) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(value);
+            }
+        });
+    });
 }
-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) {
-            const defer = new defer_1.Defer();
-            fs_1.stat(path, (err, stats) => {
-                if (err) {
-                    defer.reject(err);
-                }
-                else {
-                    if (stats.isDirectory()) {
-                        defer.resolve({ type: 'directory' });
-                    }
-                    else if (stats.isFile()) {
-                        defer.resolve({ type: 'file', lastModified: stats.mtimeMs });
+            return new Promise((resolve, reject) => {
+                (0, fs_1.stat)(getAbsolutePath(cwd, path), (err, stats) => {
+                    if (err) {
+                        reject(err);
                     }
                     else {
-                        defer.resolve({ type: 'other' });
+                        if (stats.isDirectory()) {
+                            resolve({ type: 'directory' });
+                        }
+                        else if (stats.isFile()) {
+                            resolve({ type: 'file', lastModified: stats.mtimeMs });
+                        }
+                        else {
+                            resolve({ type: 'other' });
+                        }
                     }
-                }
+                });
             });
-            return defer.promise;
         },
         appendFile(path, content) {
-            const defer = new defer_1.Defer();
-            fs_1.appendFile(path, content, handleCallback(defer));
-            return defer.promise;
+            return handleCallback((cb) => (0, fs_1.appendFile)(getAbsolutePath(cwd, path), content, cb));
         },
         writeFile(path, content) {
-            const defer = new defer_1.Defer();
-            fs_1.writeFile(path, content, handleCallback(defer));
-            return defer.promise;
+            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) {
-            const defer = new defer_1.Defer();
-            fs_1.readdir(path, handleCallback(defer));
-            return defer.promise;
+            return handleCallback((cb) => (0, fs_1.readdir)(getAbsolutePath(cwd, path), cb));
         },
         exists(path) {
-            const defer = new defer_1.Defer();
-            fs_1.stat(path, (err) => {
+            return handleCallback((cb) => (0, fs_1.stat)(getAbsolutePath(cwd, path), (err) => {
                 if (err) {
-                    defer.resolve(false);
+                    cb(null, false);
                 }
                 else {
-                    defer.resolve(true);
+                    cb(null, true);
                 }
-            });
-            return defer.promise;
+            }));
+        },
+        readStream(path) {
+            return (0, fs_1.createReadStream)(path);
         },
         read(path) {
-            const defer = new defer_1.Defer();
-            fs_1.readFile(path, (err, content) => {
+            return handleCallback((cb) => (0, fs_1.readFile)(getAbsolutePath(cwd, path), (err, content) => {
                 if (err) {
-                    defer.reject(err);
+                    cb(err, null);
                 }
                 else {
-                    defer.resolve(content.toString());
+                    cb(null, content.toString());
                 }
-            });
-            return defer.promise;
+            }));
         },
         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);
                 }
-                const defer = new defer_1.Defer();
-                fs_1.copyFile(source, destination, handleCallback(defer));
-                return defer.promise;
+                return handleCallback((cb) => (0, fs_1.copyFile)(absoluteSource, absoluteDestination, cb));
             }
         },
         createDirectory(path) {
-            const defer = new defer_1.Defer();
-            fs_1.mkdir(path, { recursive: true }, handleCallback(defer));
-            return defer.promise.then();
+            return handleCallback((cb) => (0, fs_1.mkdir)(getAbsolutePath(cwd, path), { recursive: true }, cb));
         },
-        remove(path) {
-            const defer = new defer_1.Defer();
-            fs_1.rmdir(path, { recursive: true }, handleCallback(defer));
-            return defer.promise;
+        async remove(path) {
+            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);
             });