ic-mops 1.0.1 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Mops CLI Changelog
 
+## 1.1.0
+- New `mops watch` command to check for syntax errors, show warnings, run tests, generate declarations and deploy canisters ([docs](https://docs.mops.one/cli/mops-watch))
+- New flag `--no-toolchain` in `mops install` command to skip toolchain installation
+- New lock file format v3 ([docs](https://docs.mops.one/mops.lock))
+- Faster `mops install` from lock file when lock file is up-to-date and there are no cached packages
+- Fixed replica test hanging in watch mode bug
+- Fixed mops failing when dfx is not installed
+- Fixed `mops test` Github Action template
+
 ## 1.0.1
 - Fixed `mops user *` commands
 

package/check-requirements.ts

@@ -11,7 +11,7 @@ export async function checkRequirements({verbose = false} = {}) {
 	let config = readConfig();
 	let mocVersion = config.toolchain?.moc;
 	if (!mocVersion) {
-		mocVersion = getMocVersion();
+		mocVersion = getMocVersion(false);
 	}
 	if (!mocVersion) {
 		return;

package/cli.ts

@@ -1,5 +1,6 @@
 import process from 'node:process';
 import fs from 'node:fs';
+import events from 'node:events';
 import {Command, Argument, Option} from 'commander';
 
 import {init} from './commands/init.js';
@@ -25,6 +26,7 @@ import {toolchain} from './commands/toolchain/index.js';
 import {Tool} from './types.js';
 import * as self from './commands/self.js';
 import {resolvePackages} from './resolve-packages.js';
+import {watch} from './commands/watch/watch.js';
 
 declare global {
 	// eslint-disable-next-line no-var
@@ -33,6 +35,8 @@ declare global {
 	var mopsReplicaTestRunning : boolean;
 }
 
+events.setMaxListeners(20);
+
 let networkFile = getNetworkFile();
 if (fs.existsSync(networkFile)) {
 	globalThis.MOPS_NETWORK = fs.readFileSync(networkFile).toString() || 'ic';
@@ -89,6 +93,7 @@ program
 	.command('install')
 	.alias('i')
 	.description('Install all dependencies specified in mops.toml')
+	.option('--no-toolchain', 'Do not install toolchain')
 	.option('--verbose')
 	.addOption(new Option('--lock <action>', 'Lockfile action').choices(['check', 'update', 'ignore']))
 	.action(async (options) => {
@@ -101,10 +106,15 @@ program
 			return;
 		}
 
-		await toolchain.ensureToolchainInited({strict: false});
+		if (options.toolchain) {
+			await toolchain.ensureToolchainInited({strict: false});
+		}
 
 		let ok = await installAll(options);
-		await toolchain.installAll(options);
+
+		if (options.toolchain) {
+			await toolchain.installAll(options);
+		}
 
 		// check conflicts
 		await resolvePackages({conflicts: 'warning'});
@@ -162,7 +172,7 @@ program
 			process.exit(1);
 		}
 		if (options.install) {
-			await installAll({silent: true, lock: 'ignore', threads: 6});
+			await installAll({silent: true, lock: 'ignore', threads: 6, installFromLockFile: true});
 		}
 		await toolchain.ensureToolchainInited({strict: false});
 		let sourcesArr = await sources(options);
@@ -206,7 +216,7 @@ program
 	.option('-w, --watch', 'Enable watch mode')
 	.action(async (filter, options) => {
 		checkConfigFile(true);
-		await installAll({silent: true, lock: 'ignore'});
+		await installAll({silent: true, lock: 'ignore', installFromLockFile: true});
 		await test(filter, options);
 	});
 
@@ -222,7 +232,7 @@ program
 	.addOption(new Option('--verbose', 'Show more information'))
 	.action(async (filter, options) => {
 		checkConfigFile(true);
-		await installAll({silent: true, lock: 'ignore'});
+		await installAll({silent: true, lock: 'ignore', installFromLockFile: true});
 		await bench(filter, options);
 	});
 
@@ -392,4 +402,18 @@ selfCommand
 
 program.addCommand(selfCommand);
 
+// watch
+program
+	.command('watch')
+	.description('Watch *.mo files and check for syntax errors, warnings, run tests, generate declarations and deploy canisters')
+	.option('-e, --error', 'Check Motoko canisters or *.mo files for syntax errors')
+	.option('-w, --warning', 'Check Motoko canisters or *.mo files for warnings')
+	.option('-t, --test', 'Run tests')
+	.option('-g, --generate', 'Generate declarations for Motoko canisters')
+	.option('-d, --deploy', 'Deploy Motoko canisters')
+	.action(async (options) => {
+		checkConfigFile(true);
+		await watch(options);
+	});
+
 program.parse();

package/commands/bench.ts

@@ -55,7 +55,7 @@ export async function bench(filter = '', optionsArg : Partial<BenchOptions> = {}
 		replica: config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx',
 		replicaVersion: '',
 		compiler: 'moc',
-		compilerVersion: getMocVersion(),
+		compilerVersion: getMocVersion(true),
 		gc: 'copying',
 		forceGc: true,
 		save: false,

package/commands/install/install-all.ts

@@ -1,8 +1,8 @@
 import process from 'node:process';
 import chalk from 'chalk';
 import {createLogUpdate} from 'log-update';
-import {checkConfigFile, readConfig} from '../../mops.js';
-import {checkIntegrity} from '../../integrity.js';
+import {checkConfigFile, parseDepValue, readConfig} from '../../mops.js';
+import {checkIntegrity, checkLockFileLight, readLockFile} from '../../integrity.js';
 import {installDeps} from './install-deps.js';
 import {checkRequirements} from '../../check-requirements.js';
 import {syncLocalCache} from './sync-local-cache.js';
@@ -13,9 +13,10 @@ type InstallAllOptions = {
 	silent ?: boolean;
 	lock ?: 'check' | 'update' | 'ignore';
 	threads ?: number;
+	installFromLockFile ?: boolean;
 }
 
-export async function installAll({verbose = false, silent = false, threads, lock} : InstallAllOptions = {}) : Promise<boolean> {
+export async function installAll({verbose = false, silent = false, threads, lock, installFromLockFile} : InstallAllOptions = {}) : Promise<boolean> {
 	if (!checkConfigFile()) {
 		return false;
 	}
@@ -24,12 +25,33 @@ export async function installAll({verbose = false, silent = false, threads, lock
 	let deps = Object.values(config.dependencies || {});
 	let devDeps = Object.values(config['dev-dependencies'] || {});
 	let allDeps = [...deps, ...devDeps];
+	let installedFromLockFile = false;
 
-	let ok = await installDeps(allDeps, {silent, verbose, threads});
-	if (!ok) {
-		return false;
+	// install from lock file to avoid installing intermediate dependencies
+	if ((lock !== 'ignore' || installFromLockFile) && checkLockFileLight()) {
+		let lockFileJson = readLockFile();
+
+		if (lockFileJson && lockFileJson.version === 3) {
+			verbose && console.log('Installing from lock file...');
+			installedFromLockFile = true;
+			let lockedDeps = Object.entries(lockFileJson.deps).map(([name, version]) => {
+				return parseDepValue(name, version);
+			});
+			let ok = await installDeps(lockedDeps, {silent, verbose, threads, ignoreTransitive: true});
+			if (!ok) {
+				return false;
+			}
+		}
 	}
 
+	if (!installedFromLockFile) {
+		let ok = await installDeps(allDeps, {silent, verbose, threads});
+		if (!ok) {
+			return false;
+		}
+	}
+
+
 	let logUpdate = createLogUpdate(process.stdout, {showCursor: true});
 
 	if (!silent && lock !== 'ignore') {

package/commands/install/install-dep.ts

@@ -9,13 +9,14 @@ type InstallDepOptions = {
 	verbose ?: boolean;
 	silent ?: boolean;
 	threads ?: number;
+	ignoreTransitive ?: boolean;
 };
 
 // install dependency
 // returns false if failed
-export async function installDep(dep : Dependency, {verbose, silent, threads} : InstallDepOptions = {}, parentPkgPath ?: string) : Promise<boolean> {
+export async function installDep(dep : Dependency, {verbose, silent, threads, ignoreTransitive} : InstallDepOptions = {}, parentPkgPath ?: string) : Promise<boolean> {
 	if (dep.repo) {
-		await installFromGithub(dep.name, dep.repo, {silent, verbose});
+		await installFromGithub(dep.name, dep.repo, {silent, verbose, ignoreTransitive});
 		return true;
 	}
 	else if (dep.path) {
@@ -24,10 +25,10 @@ export async function installDep(dep : Dependency, {verbose, silent, threads} :
 		if (parentPkgPath) {
 			depPath = path.resolve(parentPkgPath, dep.path);
 		}
-		return installLocalDep(dep.name, depPath, {silent, verbose});
+		return installLocalDep(dep.name, depPath, {silent, verbose, ignoreTransitive});
 	}
 	else if (dep.version) {
-		return installMopsDep(dep.name, dep.version, {silent, verbose, threads});
+		return installMopsDep(dep.name, dep.version, {silent, verbose, threads, ignoreTransitive});
 	}
 
 	return true;

package/commands/install/install-deps.ts

@@ -5,16 +5,17 @@ type InstallDepsOptions = {
 	verbose ?: boolean;
 	silent ?: boolean;
 	threads ?: number;
+	ignoreTransitive ?: boolean;
 };
 
 // install all dependencies
 // returns actual installed dependencies
 // returns false if failed
-export async function installDeps(deps : Dependency[], {verbose, silent, threads} : InstallDepsOptions = {}, parentPkgPath ?: string) : Promise<boolean> {
+export async function installDeps(deps : Dependency[], {verbose, silent, threads, ignoreTransitive} : InstallDepsOptions = {}, parentPkgPath ?: string) : Promise<boolean> {
 	let ok = true;
 
 	for (const dep of deps) {
-		let res = await installDep(dep, {verbose, silent, threads}, parentPkgPath);
+		let res = await installDep(dep, {verbose, silent, threads, ignoreTransitive}, parentPkgPath);
 		if (!res) {
 			ok = false;
 		}

package/commands/install/install-local-dep.ts

@@ -7,11 +7,12 @@ import {installDeps} from './install-deps.js';
 type InstallLocalDepOptions = {
 	verbose ?: boolean;
 	silent ?: boolean;
+	ignoreTransitive ?: boolean;
 };
 
 // skip install and just find non-local dependencies to install
 // pkgPath should be relative to the current root dir or absolute
-export async function installLocalDep(pkg : string, pkgPath = '', {verbose, silent} : InstallLocalDepOptions = {}) : Promise<boolean> {
+export async function installLocalDep(pkg : string, pkgPath = '', {verbose, silent, ignoreTransitive} : InstallLocalDepOptions = {}) : Promise<boolean> {
 	if (!silent) {
 		let logUpdate = createLogUpdate(process.stdout, {showCursor: true});
 		logUpdate(`Local dependency ${pkg} = "${pkgPath}"`);
@@ -25,7 +26,12 @@ export async function installLocalDep(pkg : string, pkgPath = '', {verbose, sile
 	}
 
 	// install dependencies
-	let dir = path.resolve(getRootDir(), pkgPath);
-	let config = readConfig(path.join(dir, 'mops.toml'));
-	return installDeps(Object.values(config.dependencies || {}), {silent, verbose}, pkgPath);
-}
+	if (!ignoreTransitive) {
+		let dir = path.resolve(getRootDir(), pkgPath);
+		let config = readConfig(path.join(dir, 'mops.toml'));
+		return installDeps(Object.values(config.dependencies || {}), {silent, verbose}, pkgPath);
+	}
+	else {
+		return true;
+	}
+}

package/commands/install/install-mops-dep.ts

@@ -19,9 +19,10 @@ type InstallMopsDepOptions = {
 	silent ?: boolean;
 	dep ?: boolean;
 	threads ?: number;
+	ignoreTransitive ?: boolean;
 };
 
-export async function installMopsDep(pkg : string, version = '', {verbose, silent, dep, threads} : InstallMopsDepOptions = {}) : Promise<boolean> {
+export async function installMopsDep(pkg : string, version = '', {verbose, silent, dep, threads, ignoreTransitive} : InstallMopsDepOptions = {}) : Promise<boolean> {
 	threads = threads || 12;
 	let depName = getDepName(pkg);
 
@@ -113,11 +114,13 @@ export async function installMopsDep(pkg : string, version = '', {verbose, silen
 	}
 
 	// install dependencies
-	let config = readConfig(path.join(cacheDir, 'mops.toml'));
-	let res = await installDeps(Object.values(config.dependencies || {}), {silent, verbose});
+	if (!ignoreTransitive) {
+		let config = readConfig(path.join(cacheDir, 'mops.toml'));
+		let res = await installDeps(Object.values(config.dependencies || {}), {silent, verbose});
 
-	if (!res) {
-		return false;
+		if (!res) {
+			return false;
+		}
 	}
 
 	return true;

package/commands/replica.ts

@@ -3,6 +3,7 @@ import {ChildProcessWithoutNullStreams, execSync, spawn} from 'node:child_proces
 import path from 'node:path';
 import fs from 'node:fs';
 import {PassThrough} from 'node:stream';
+import {spawn as spawnAsync} from 'promisify-child-process';
 
 import {IDL} from '@dfinity/candid';
 import {Actor, HttpAgent} from '@dfinity/agent';
@@ -126,7 +127,7 @@ export class Replica {
 		}
 	}
 
-	async deploy(name : string, wasm : string, idlFactory : IDL.InterfaceFactory, cwd : string = process.cwd()) {
+	async deploy(name : string, wasm : string, idlFactory : IDL.InterfaceFactory, cwd : string = process.cwd(), signal ?: AbortSignal) {
 		if (this.type === 'dfx') {
 			// prepare dfx.json for current canister
 			let dfxJson = path.join(this.dir, 'dfx.json');
@@ -144,8 +145,27 @@ export class Replica {
 			fs.mkdirSync(this.dir, {recursive: true});
 			fs.writeFileSync(dfxJson, JSON.stringify(newDfxJsonData, null, 2));
 
-			execSync(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, {cwd: this.dir, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe']});
-			execSync(`dfx ledger fabricate-cycles --canister ${name} --t 100`, {cwd: this.dir, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe']});
+			await spawnAsync('dfx', ['deploy', name, '--mode', 'reinstall', '--yes', '--identity', 'anonymous'], {cwd: this.dir, signal, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe']}).catch((error) => {
+				if (error.code === 'ABORT_ERR') {
+					return {stderr: ''};
+				}
+				throw error;
+			});
+
+			if (signal?.aborted) {
+				return;
+			}
+
+			await spawnAsync('dfx', ['ledger', 'fabricate-cycles', '--canister', name, '--t', '100'], {cwd: this.dir, signal, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe']}).catch((error) => {
+				if (error.code === 'ABORT_ERR') {
+					return {stderr: ''};
+				}
+				throw error;
+			});
+
+			if (signal?.aborted) {
+				return;
+			}
 
 			let canisterId = execSync(`dfx canister id ${name}`, {cwd: this.dir}).toString().trim();
 
@@ -170,7 +190,17 @@ export class Replica {
 				idlFactory,
 				wasm,
 			});
+
+			if (signal?.aborted) {
+				return;
+			}
+
 			await this.pocketIc.addCycles(canisterId, 1_000_000_000_000);
+
+			if (signal?.aborted) {
+				return;
+			}
+
 			this.canisters[name] = {
 				cwd,
 				canisterId: canisterId.toText(),

package/commands/sources.ts

@@ -45,5 +45,5 @@ export async function sources({conflicts = 'ignore' as 'warning' | 'error' | 'ig
 		}
 
 		return `--package ${name} ${pkgBaseDir}`;
-	});
+	}).filter(x => x != null);
 }

package/commands/sync.ts

@@ -1,4 +1,3 @@
-import process from 'node:process';
 import path from 'node:path';
 import {execSync} from 'node:child_process';
 import {globSync} from 'glob';
@@ -7,6 +6,7 @@ import {checkConfigFile, getRootDir, readConfig} from '../mops.js';
 import {add} from './add.js';
 import {remove} from './remove.js';
 import {checkIntegrity} from '../integrity.js';
+import {getMocPath} from '../helpers/get-moc-path.js';
 
 type SyncOptions = {
 	lock ?: 'update' | 'ignore';
@@ -48,25 +48,10 @@ let ignore = [
 	'**/.mops/**',
 ];
 
-let mocPath = '';
-function getMocPath() : string {
-	if (!mocPath) {
-		mocPath = process.env.DFX_MOC_PATH || '';
-	}
-	if (!mocPath) {
-		try {
-			mocPath = execSync('dfx cache show').toString().trim() + '/moc';
-		}
-		catch {}
-	}
-	if (!mocPath) {
-		mocPath = 'moc';
-	}
-	return mocPath;
-}
-
 async function getUsedPackages() : Promise<string[]> {
 	let rootDir = getRootDir();
+	let mocPath = getMocPath();
+
 	let files = globSync('**/*.mo', {
 		cwd: rootDir,
 		nocase: true,
@@ -76,7 +61,7 @@ async function getUsedPackages() : Promise<string[]> {
 	let packages : Set<string> = new Set;
 
 	for (let file of files) {
-		let deps : string[] = execSync(`${getMocPath()} --print-deps ${path.join(rootDir, file)}`).toString().trim().split('\n');
+		let deps : string[] = execSync(`${mocPath} --print-deps ${path.join(rootDir, file)}`).toString().trim().split('\n');
 
 		for (let dep of deps) {
 			if (dep.startsWith('mo:') && !dep.startsWith('mo:prim') && !dep.startsWith('mo:⛔')) {

package/commands/test/mmf1.ts

@@ -53,6 +53,10 @@ export class MMF1 {
 		this.output = [];
 	}
 
+	getErrorMessages() {
+		return this.output.filter(out => out.type === 'fail').map(out => out.message);
+	}
+
 	parseLine(line : string) {
 		if (line.startsWith('mops:1:start ')) {
 			this._testStart(line.split('mops:1:start ')[1] || '');

package/commands/test/reporters/silent-reporter.ts

@@ -5,14 +5,25 @@ import {Reporter} from './reporter.js';
 import {TestMode} from '../../../types.js';
 
 export class SilentReporter implements Reporter {
+	total = 0;
 	passed = 0;
 	failed = 0;
 	skipped = 0;
 	passedFiles = 0;
 	failedFiles = 0;
 	passedNamesFlat : string[] = [];
+	flushOnError = true;
+	errorOutput = '';
+	onProgress = () => {};
 
-	addFiles(_files : string[]) {}
+	constructor(flushOnError = true, onProgress = () => {}) {
+		this.flushOnError = flushOnError;
+		this.onProgress = onProgress;
+	}
+
+	addFiles(files : string[]) {
+		this.total = files.length;
+	}
 
 	addRun(file : string, mmf : MMF1, state : Promise<void>, _mode : TestMode) {
 		state.then(() => {
@@ -30,10 +41,17 @@ export class SilentReporter implements Reporter {
 			this.failedFiles += Number(mmf.failed !== 0);
 
 			if (mmf.failed) {
-				console.log(chalk.red('✖'), absToRel(file));
-				mmf.flush('fail');
-				console.log('-'.repeat(50));
+				let output = `${chalk.red('✖')} ${absToRel(file)}\n${mmf.getErrorMessages().join('\n')}\n${'-'.repeat(50)}`;
+
+				if (this.flushOnError) {
+					console.log(output);
+				}
+				else {
+					this.errorOutput = `${this.errorOutput}\n${output}`.trim();
+				}
 			}
+
+			this.onProgress();
 		});
 	}
 

package/commands/test/test.ts

@@ -85,14 +85,28 @@ export async function test(filter = '', options : Partial<TestOptions> = {}) {
 					process.exit(0);
 				});
 			}
+			else {
+				process.exit(0);
+			}
 		});
 
 		// todo: run only changed for *.test.mo?
 		// todo: run all for *.mo?
+
+		let curRun = Promise.resolve(true);
+		let controller = new AbortController();
+
 		let run = debounce(async () => {
+			controller.abort();
+			await curRun;
+
 			console.clear();
 			process.stdout.write('\x1Bc');
-			await runAll(options.reporter, filter, options.mode, replicaType, true);
+
+			controller = new AbortController();
+			curRun = runAll(options.reporter, filter, options.mode, replicaType, true, controller.signal);
+			await curRun;
+
 			console.log('-'.repeat(50));
 			console.log('Waiting for file changes...');
 			console.log(chalk.gray((`Press ${chalk.gray('Ctrl+C')} to exit.`)));
@@ -122,12 +136,12 @@ export async function test(filter = '', options : Partial<TestOptions> = {}) {
 let mocPath = '';
 let wasmtimePath = '';
 
-async function runAll(reporterName : ReporterName | undefined, filter = '', mode : TestMode = 'interpreter', replicaType : ReplicaName, watch = false) : Promise<boolean> {
-	let done = await testWithReporter(reporterName, filter, mode, replicaType, watch);
+async function runAll(reporterName : ReporterName | undefined, filter = '', mode : TestMode = 'interpreter', replicaType : ReplicaName, watch = false, signal ?: AbortSignal) : Promise<boolean> {
+	let done = await testWithReporter(reporterName, filter, mode, replicaType, watch, signal);
 	return done;
 }
 
-export async function testWithReporter(reporterName : ReporterName | Reporter | undefined, filter = '', defaultMode : TestMode = 'interpreter', replicaType : ReplicaName, watch = false) : Promise<boolean> {
+export async function testWithReporter(reporterName : ReporterName | Reporter | undefined, filter = '', defaultMode : TestMode = 'interpreter', replicaType : ReplicaName, watch = false, signal ?: AbortSignal) : Promise<boolean> {
 	let rootDir = getRootDir();
 	let files : string[] = [];
 	let libFiles = globSync('**/test?(s)/lib.mo', globConfig);
@@ -191,6 +205,10 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 	fs.mkdirSync(testTempDir, {recursive: true});
 
 	await parallel(os.cpus().length, files, async (file : string) => {
+		if (signal?.aborted) {
+			return;
+		}
+
 		let mmf = new MMF1('store', absToRel(file));
 
 		// mode overrides
@@ -221,7 +239,13 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 
 			// interpret
 			if (mode === 'interpreter') {
-				let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs]);
+				let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs], {signal});
+				proc.addListener('error', (error : any) => {
+					if (error?.code === 'ABORT_ERR') {
+						return;
+					}
+					throw error;
+				});
 				pipeMMF(proc, mmf).then(resolve);
 			}
 			// build and run wasm
@@ -229,7 +253,13 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 				let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
 
 				// build
-				let buildProc = spawn(mocPath, [`-o=${wasmFile}`, '-wasi-system-api', ...mocArgs]);
+				let buildProc = spawn(mocPath, [`-o=${wasmFile}`, '-wasi-system-api', ...mocArgs], {signal});
+				buildProc.addListener('error', (error : any) => {
+					if (error?.code === 'ABORT_ERR') {
+						return;
+					}
+					throw error;
+				});
 				pipeMMF(buildProc, mmf).then(async () => {
 					if (mmf.failed > 0) {
 						return;
@@ -252,7 +282,14 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 						process.exit(1);
 					}
 
-					let proc = spawn(wasmtimePath, wasmtimeArgs);
+					let proc = spawn(wasmtimePath, wasmtimeArgs, {signal});
+					proc.addListener('error', (error : any) => {
+						if (error?.code === 'ABORT_ERR') {
+							return;
+						}
+						throw error;
+					});
+
 					await pipeMMF(proc, mmf);
 				}).finally(() => {
 					fs.rmSync(wasmFile, {force: true});
@@ -265,7 +302,13 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 				let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
 
 				// build
-				let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs]);
+				let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs], {signal});
+				buildProc.addListener('error', (error : any) => {
+					if (error?.code === 'ABORT_ERR') {
+						return;
+					}
+					throw error;
+				});
 
 				pipeMMF(buildProc, mmf).then(async () => {
 					if (mmf.failed > 0) {
@@ -274,15 +317,23 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 
 					await startReplicaOnce(replica, replicaType);
 
+					if (signal?.aborted) {
+						return;
+					}
+
 					let canisterName = path.parse(file).name;
 					let idlFactory = ({IDL} : any) => {
 						return IDL.Service({'runTests': IDL.Func([], [], [])});
 					};
 					interface _SERVICE {'runTests' : ActorMethod<[], undefined>;}
 
-					let {stream} = await replica.deploy(canisterName, wasmFile, idlFactory);
+					let canister = await replica.deploy(canisterName, wasmFile, idlFactory, undefined, signal);
 
-					pipeStdoutToMMF(stream, mmf);
+					if (signal?.aborted || !canister) {
+						return;
+					}
+
+					pipeStdoutToMMF(canister.stream, mmf);
 
 					let actor = await replica.getActor(canisterName) as _SERVICE;
 
@@ -298,6 +349,10 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 							});
 						}
 
+						if (signal?.aborted) {
+							return;
+						}
+
 						globalThis.mopsReplicaTestRunning = true;
 						await actor.runTests();
 						globalThis.mopsReplicaTestRunning = false;
@@ -310,11 +365,16 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 						stderrStream.write(e.message);
 					}
 				}).finally(async () => {
+					globalThis.mopsReplicaTestRunning = false;
 					fs.rmSync(wasmFile, {force: true});
 				}).then(resolve);
 			}
 		});
 
+		if (signal?.aborted) {
+			return;
+		}
+
 		reporter.addRun(file, mmf, promise, mode);
 
 		await promise;
@@ -325,6 +385,10 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 		fs.rmSync(testTempDir, {recursive: true, force: true});
 	}
 
+	if (signal?.aborted) {
+		return false;
+	}
+
 	return reporter.done();
 }