ic-mops 0.45.3 → 1.0.0-pre.0

package/commands/test/test.ts

@@ -3,6 +3,7 @@ import {spawn, ChildProcessWithoutNullStreams} from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
 import os from 'node:os';
+
 import chalk from 'chalk';
 import {globSync} from 'glob';
 import chokidar from 'chokidar';
@@ -20,6 +21,10 @@ import {FilesReporter} from './reporters/files-reporter.js';
 import {CompactReporter} from './reporters/compact-reporter.js';
 import {SilentReporter} from './reporters/silent-reporter.js';
 import {toolchain} from '../toolchain/index.js';
+import {Replica} from '../replica.js';
+import {ActorMethod} from '@dfinity/agent';
+import {PassThrough, Readable} from 'node:stream';
+import {TestMode} from '../../types.js';
 
 let ignore = [
 	'**/node_modules/**',
@@ -34,18 +39,60 @@ let globConfig = {
 };
 
 type ReporterName = 'verbose' | 'files' | 'compact' | 'silent';
-type TestMode = 'interpreter' | 'wasi';
+type ReplicaName = 'dfx' | 'pocket-ic';
+
+type TestOptions = {
+	watch : boolean;
+	reporter : ReporterName;
+	mode : TestMode;
+	replica : ReplicaName;
+};
+
+
+let replica = new Replica();
+let replicaStartPromise : Promise<void> | undefined;
+
+async function startReplicaOnce(replica : Replica, type : ReplicaName) {
+	if (!replicaStartPromise) {
+		replicaStartPromise = new Promise((resolve) => {
+			replica.start({type, silent: true}).then(resolve);
+		});
+	}
+	return replicaStartPromise;
+}
 
-export async function test(filter = '', {watch = false, reporter = 'verbose' as ReporterName, mode = 'interpreter' as TestMode} = {}) {
+export async function test(filter = '', options : Partial<TestOptions> = {}) {
+	let config = readConfig();
 	let rootDir = getRootDir();
 
-	if (watch) {
+	let replicaType = options.replica ?? (config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx' as ReplicaName);
+	replica.type = replicaType;
+
+	if (options.watch) {
+		replica.ttl = 60 * 15; // 15 minutes
+
+		let sigint = false;
+		process.on('SIGINT', () => {
+			if (sigint) {
+				console.log('Force exit');
+				process.exit(0);
+			}
+			sigint = true;
+
+			if (replicaStartPromise) {
+				console.log('Stopping replica...');
+				replica.stop(true).then(() => {
+					process.exit(0);
+				});
+			}
+		});
+
 		// todo: run only changed for *.test.mo?
 		// todo: run all for *.mo?
 		let run = debounce(async () => {
 			console.clear();
 			process.stdout.write('\x1Bc');
-			await runAll(reporter, filter, mode);
+			await runAll(options.reporter, filter, options.mode, replicaType, true);
 			console.log('-'.repeat(50));
 			console.log('Waiting for file changes...');
 			console.log(chalk.gray((`Press ${chalk.gray('Ctrl+C')} to exit.`)));
@@ -65,7 +112,7 @@ export async function test(filter = '', {watch = false, reporter = 'verbose' as
 		run();
 	}
 	else {
-		let passed = await runAll(reporter, filter, mode);
+		let passed = await runAll(options.reporter, filter, options.mode, replicaType);
 		if (!passed) {
 			process.exit(1);
 		}
@@ -75,25 +122,12 @@ export async function test(filter = '', {watch = false, reporter = 'verbose' as
 let mocPath = '';
 let wasmtimePath = '';
 
-export async function runAll(reporterName : ReporterName = 'verbose', filter = '', mode : TestMode = 'interpreter') : Promise<boolean> {
-	let reporter : Reporter;
-	if (reporterName == 'compact') {
-		reporter = new CompactReporter;
-	}
-	else if (reporterName == 'files') {
-		reporter = new FilesReporter;
-	}
-	else if (reporterName == 'silent') {
-		reporter = new SilentReporter;
-	}
-	else {
-		reporter = new VerboseReporter;
-	}
-	let done = await testWithReporter(reporter, filter, mode);
+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);
 	return done;
 }
 
-export async function testWithReporter(reporter : Reporter, filter = '', mode : TestMode = 'interpreter') : Promise<boolean> {
+export async function testWithReporter(reporterName : ReporterName | Reporter | undefined, filter = '', defaultMode : TestMode = 'interpreter', replicaType : ReplicaName, watch = false) : Promise<boolean> {
 	let rootDir = getRootDir();
 	let files : string[] = [];
 	let libFiles = globSync('**/test?(s)/lib.mo', globConfig);
@@ -117,6 +151,31 @@ export async function testWithReporter(reporter : Reporter, filter = '', mode :
 		return false;
 	}
 
+
+	let reporter : Reporter;
+
+	if (!reporterName || typeof reporterName === 'string') {
+		if (!reporterName) {
+			reporterName = files.length > 1 ? 'files' : 'verbose';
+		}
+
+		if (reporterName == 'compact') {
+			reporter = new CompactReporter;
+		}
+		else if (reporterName == 'files') {
+			reporter = new FilesReporter;
+		}
+		else if (reporterName == 'silent') {
+			reporter = new SilentReporter;
+		}
+		else {
+			reporter = new VerboseReporter;
+		}
+	}
+	else {
+		reporter = reporterName;
+	}
+
 	reporter.addFiles(files);
 
 	let config = readConfig();
@@ -126,14 +185,25 @@ export async function testWithReporter(reporter : Reporter, filter = '', mode :
 		mocPath = await toolchain.bin('moc', {fallback: true});
 	}
 
-	let wasmDir = `${getRootDir()}/.mops/.test/`;
-	fs.mkdirSync(wasmDir, {recursive: true});
+	let testTempDir = path.join(getRootDir(), '.mops/.test/');
+	replica.dir = testTempDir;
+
+	fs.mkdirSync(testTempDir, {recursive: true});
 
 	await parallel(os.cpus().length, files, async (file : string) => {
 		let mmf = new MMF1('store', absToRel(file));
-		let wasiMode = mode === 'wasi' || fs.readFileSync(file, 'utf8').startsWith('// @testmode wasi');
 
-		if (wasiMode && !wasmtimePath) {
+		// mode overrides
+		let lines = fs.readFileSync(file, 'utf8').split('\n');
+		let mode = defaultMode;
+		if (lines.includes('// @testmode wasi')) {
+			mode = 'wasi';
+		}
+		else if (lines.includes('actor {') || lines.includes('// @testmode replica')) {
+			mode = 'replica';
+		}
+
+		if (mode === 'wasi' && !wasmtimePath) {
 			// ensure wasmtime is installed or specified in config
 			if (config.toolchain?.wasmtime) {
 				wasmtimePath = await toolchain.bin('wasmtime');
@@ -149,9 +219,14 @@ export async function testWithReporter(reporter : Reporter, filter = '', mode :
 		let promise = new Promise<void>((resolve) => {
 			let mocArgs = ['--hide-warnings', '--error-detail=2', ...sourcesArr.join(' ').split(' '), file].filter(x => x);
 
+			// interpret
+			if (mode === 'interpreter') {
+				let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs]);
+				pipeMMF(proc, mmf).then(resolve);
+			}
 			// build and run wasm
-			if (wasiMode) {
-				let wasmFile = `${path.join(wasmDir, path.parse(file).name)}.wasm`;
+			else if (mode === 'wasi') {
+				let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
 
 				// build
 				let buildProc = spawn(mocPath, [`-o=${wasmFile}`, '-wasi-system-api', ...mocArgs]);
@@ -172,6 +247,7 @@ export async function testWithReporter(reporter : Reporter, filter = '', mode :
 							wasmFile,
 						];
 					}
+					// backcompat
 					else {
 						wasmtimeArgs = [
 							'--max-wasm-stack=4000000',
@@ -188,72 +264,135 @@ export async function testWithReporter(reporter : Reporter, filter = '', mode :
 					fs.rmSync(wasmFile, {force: true});
 				}).then(resolve);
 			}
-			// interpret
-			else {
-				let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs]);
-				pipeMMF(proc, mmf).then(resolve);
+			// build and execute in replica
+			else if (mode === 'replica') {
+				// mmf.strategy = 'print'; // because we run replica tests one-by-one
+
+				let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
+
+				// build
+				let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs]);
+
+				pipeMMF(buildProc, mmf).then(async () => {
+					if (mmf.failed > 0) {
+						return;
+					}
+
+					await startReplicaOnce(replica, replicaType);
+
+					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);
+
+					pipeStdoutToMMF(stream, mmf);
+
+					let actor = await replica.getActor(canisterName) as _SERVICE;
+
+					try {
+						if (globalThis.mopsReplicaTestRunning) {
+							await new Promise<void>((resolve) => {
+								let timerId = setInterval(() => {
+									if (!globalThis.mopsReplicaTestRunning) {
+										resolve();
+										clearInterval(timerId);
+									}
+								}, Math.random() * 1000 |0);
+							});
+						}
+
+						globalThis.mopsReplicaTestRunning = true;
+						await actor.runTests();
+						globalThis.mopsReplicaTestRunning = false;
+
+						mmf.pass();
+					}
+					catch (e : any) {
+						let stderrStream = new PassThrough();
+						pipeStderrToMMF(stderrStream, mmf, path.dirname(file));
+						stderrStream.write(e.message);
+					}
+				}).finally(async () => {
+					fs.rmSync(wasmFile, {force: true});
+				}).then(resolve);
 			}
 		});
 
-		reporter.addRun(file, mmf, promise, wasiMode);
+		reporter.addRun(file, mmf, promise, mode);
 
 		await promise;
 	});
 
-	fs.rmSync(wasmDir, {recursive: true, force: true});
+	if (replicaStartPromise && !watch) {
+		await replica.stop();
+		fs.rmSync(testTempDir, {recursive: true, force: true});
+	}
+
 	return reporter.done();
 }
 
-function pipeMMF(proc : ChildProcessWithoutNullStreams, mmf : MMF1) {
-	return new Promise<void>((resolve) => {
-		// stdout
-		proc.stdout.on('data', (data) => {
-			for (let line of data.toString().split('\n')) {
-				line = line.trim();
-				if (line) {
-					mmf.parseLine(line);
-				}
+function pipeStdoutToMMF(stdout : Readable, mmf : MMF1) {
+	stdout.on('data', (data) => {
+		for (let line of data.toString().split('\n')) {
+			line = line.trim();
+			if (line) {
+				mmf.parseLine(line);
 			}
-		});
+		}
+	});
+}
+
+function pipeStderrToMMF(stderr : Readable, mmf : MMF1, dir = '') {
+	stderr.on('data', (data) => {
+		let text : string = data.toString().trim();
+		let failedLine = '';
+
+		text = text.replace(/([\w+._/-]+):(\d+).(\d+)(-\d+.\d+)/g, (_m0, m1 : string, m2 : string, m3 : string) => {
+			// change absolute file path to relative
+			// change :line:col-line:col to :line:col to work in vscode
+			let res = `${absToRel(m1)}:${m2}:${m3}`;
+			let file = path.join(dir, m1);
 
-		// stderr
-		proc.stderr.on('data', (data) => {
-			let text : string = data.toString().trim();
-			let failedLine = '';
-			text = text.replace(/([\w+._/-]+):(\d+).(\d+)(-\d+.\d+)/g, (_m0, m1 : string, m2 : string, m3 : string) => {
-				// change absolute file path to relative
-				// change :line:col-line:col to :line:col to work in vscode
-				let res = `${absToRel(m1)}:${m2}:${m3}`;
-
-				if (!fs.existsSync(m1)) {
-					return res;
-				}
-
-				// show failed line
-				let content = fs.readFileSync(m1);
-				let lines = content.toString().split('\n') || [];
-				failedLine += chalk.dim('\n   ...');
-				let lineBefore = lines[+m2 - 2];
-				if (lineBefore) {
-					failedLine += chalk.dim(`\n   ${+m2 - 1}\t| ${lineBefore.replaceAll('\t', '  ')}`);
-				}
-				failedLine += `\n${chalk.redBright`->`} ${m2}\t| ${lines[+m2 - 1]?.replaceAll('\t', '  ')}`;
-				if (lines.length > +m2) {
-					failedLine += chalk.dim(`\n   ${+m2 + 1}\t| ${lines[+m2]?.replaceAll('\t', '  ')}`);
-				}
-				failedLine += chalk.dim('\n   ...');
+			if (!fs.existsSync(file)) {
 				return res;
-			});
-			if (failedLine) {
-				text += failedLine;
 			}
-			mmf.fail(text);
+
+			// show failed line
+			let content = fs.readFileSync(file);
+			let lines = content.toString().split('\n') || [];
+
+			failedLine += chalk.dim('\n   ...');
+
+			let lineBefore = lines[+m2 - 2];
+			if (lineBefore) {
+				failedLine += chalk.dim(`\n   ${+m2 - 1}\t| ${lineBefore.replaceAll('\t', '  ')}`);
+			}
+			failedLine += `\n${chalk.redBright`->`} ${m2}\t| ${lines[+m2 - 1]?.replaceAll('\t', '  ')}`;
+			if (lines.length > +m2) {
+				failedLine += chalk.dim(`\n   ${+m2 + 1}\t| ${lines[+m2]?.replaceAll('\t', '  ')}`);
+			}
+			failedLine += chalk.dim('\n   ...');
+			return res;
 		});
+		if (failedLine) {
+			text += failedLine;
+		}
+		mmf.fail(text);
+	});
+}
+
+function pipeMMF(proc : ChildProcessWithoutNullStreams, mmf : MMF1) {
+	return new Promise<void>((resolve) => {
+		pipeStdoutToMMF(proc.stdout, mmf);
+		pipeStderrToMMF(proc.stderr, mmf);
 
 		// exit
 		proc.on('close', (code) => {
 			if (code === 0) {
-				mmf.pass();
+				mmf.strategy !== 'print' && mmf.pass();
 			}
 			else if (code !== 1) {
 				mmf.fail(`unknown exit code: ${code}`);

package/commands/user.ts

@@ -1,7 +1,13 @@
 import process from 'node:process';
 import chalk from 'chalk';
-import {getIdentity} from '../mops.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import {Buffer} from 'node:buffer';
+import prompts from 'prompts';
+import {deleteSync} from 'del';
 import {mainActor} from '../api/actors.js';
+import {getIdentity, globalConfigDir} from '../mops.js';
+import {encrypt} from '../pem.js';
 
 export async function getUserProp(prop : string) {
 	let actor = await mainActor();
@@ -26,4 +32,68 @@ export async function setUserProp(prop : string, value : string) {
 	else {
 		console.log(chalk.red('Error: ') + res.err);
 	}
+}
+
+export async function getPrincipal() {
+	let identity = await getIdentity();
+	if (identity) {
+		console.log(identity.getPrincipal().toText());
+	}
+	else {
+		console.log(chalk.red('Error: ') + 'identity not found. Run ' + chalk.greenBright('mops user import') + ' command.');
+	}
+}
+
+type ImportIdentityOptions = {
+	encrypt : boolean;
+};
+
+export async function importPem(data : string, options : ImportIdentityOptions = {encrypt: true}) {
+	try {
+		if (!fs.existsSync(globalConfigDir)) {
+			fs.mkdirSync(globalConfigDir);
+		}
+
+		let password = '';
+
+		if (options.encrypt) {
+			let res = await prompts({
+				type: 'invisible',
+				name: 'password',
+				message: 'Enter password to encrypt identity.pem',
+			});
+			password = res.password;
+
+			if (!password) {
+				let res = await prompts({
+					type: 'confirm',
+					name: 'ok',
+					message: 'Are you sure you don\'t want to protect your identity.pem with a password?',
+				});
+				if (!res.ok) {
+					console.log('aborted');
+					return;
+				}
+			}
+		}
+
+		let identityPem = path.resolve(globalConfigDir, 'identity.pem');
+		let identityPemEncrypted = path.resolve(globalConfigDir, 'identity.pem.encrypted');
+
+		deleteSync([identityPem, identityPemEncrypted], {force: true});
+
+		// encrypted
+		if (password) {
+			let encrypted = await encrypt(Buffer.from(data), password);
+			fs.writeFileSync(identityPemEncrypted, encrypted);
+		}
+		// unencrypted
+		else {
+			fs.writeFileSync(identityPem, data);
+		}
+		console.log(chalk.green('Success'));
+	}
+	catch (err) {
+		console.log(chalk.red('Error: ') + err);
+	}
 }

package/declarations/bench/bench.did

@@ -1,4 +1,4 @@
-type _anon_class_10_1 = 
+type _anon_class_10_1 =
  service {
    getSchema: () -> (BenchSchema) query;
    getStats: () -> (BenchResult) query;
@@ -7,20 +7,24 @@ type _anon_class_10_1 =
    runCellUpdate: (nat, nat) -> (BenchResult);
    runCellUpdateAwait: (nat, nat) -> (BenchResult);
  };
-type BenchSchema = 
+type BenchSchema =
  record {
    cols: vec text;
    description: text;
    name: text;
    rows: vec text;
  };
-type BenchResult = 
+type BenchResult =
  record {
    instructions: int;
-   rts_collector_instructions: int;
    rts_heap_size: int;
+   stable_memory_size: int;
+   rts_stable_memory_size: int;
+   rts_collector_instructions: int;
    rts_memory_size: int;
    rts_mutator_instructions: int;
    rts_total_allocation: int;
+   rts_logical_stable_memory_size: int;
+   rts_reclaimed: int;
  };
 service : () -> _anon_class_10_1

package/declarations/bench/bench.did.d.ts

@@ -5,10 +5,14 @@ import type { IDL } from '@dfinity/candid';
 export interface BenchResult {
   'instructions' : bigint,
   'rts_memory_size' : bigint,
+  'stable_memory_size' : bigint,
+  'rts_stable_memory_size' : bigint,
+  'rts_logical_stable_memory_size' : bigint,
   'rts_total_allocation' : bigint,
   'rts_collector_instructions' : bigint,
   'rts_mutator_instructions' : bigint,
   'rts_heap_size' : bigint,
+  'rts_reclaimed' : bigint,
 }
 export interface BenchSchema {
   'cols' : Array<string>,

package/declarations/bench/bench.did.js

@@ -7,11 +7,15 @@ export const idlFactory = ({ IDL }) => {
   });
   const BenchResult = IDL.Record({
     'instructions' : IDL.Int,
+    'stable_memory_size' : IDL.Int,
+    'rts_stable_memory_size' : IDL.Int,
+    'rts_logical_stable_memory_size' : IDL.Int,
     'rts_memory_size' : IDL.Int,
     'rts_total_allocation' : IDL.Int,
     'rts_collector_instructions' : IDL.Int,
     'rts_mutator_instructions' : IDL.Int,
     'rts_heap_size' : IDL.Int,
+    'rts_reclaimed' : IDL.Int,
   });
   const _anon_class_10_1 = IDL.Service({
     'getSchema' : IDL.Func([], [BenchSchema], ['query']),

package/dist/api/actors.js

@@ -3,28 +3,34 @@ import { idlFactory } from '../declarations/main/main.did.js';
 import { idlFactory as storageIdlFactory } from '../declarations/storage/storage.did.js';
 import { getEndpoint } from './network.js';
 import { getNetwork } from './network.js';
+let agentPromiseByPrincipal = new Map();
+let getAgent = async (identity) => {
+    let principal = identity ? identity?.getPrincipal().toText() : '';
+    let agentPromise = agentPromiseByPrincipal.get(principal);
+    if (!agentPromise) {
+        let network = getNetwork();
+        let host = getEndpoint(network).host;
+        agentPromise = HttpAgent.create({
+            host,
+            identity,
+            shouldFetchRootKey: network === 'local',
+            verifyQuerySignatures: process.env.MOPS_VERIFY_QUERY_SIGNATURES !== 'false',
+        });
+        agentPromiseByPrincipal.set(principal, agentPromise);
+    }
+    return agentPromise;
+};
 export let mainActor = async (identity) => {
+    let agent = await getAgent(identity);
     let network = getNetwork();
-    let host = getEndpoint(network).host;
     let canisterId = getEndpoint(network).canisterId;
-    // @ts-ignore exactOptionalPropertyTypes
-    let agent = new HttpAgent({ host, identity });
-    if (network === 'local') {
-        await agent.fetchRootKey();
-    }
     return Actor.createActor(idlFactory, {
         agent,
         canisterId,
     });
 };
 export let storageActor = async (storageId, identity) => {
-    let network = getNetwork();
-    let host = getEndpoint(network).host;
-    // @ts-ignore exactOptionalPropertyTypes
-    let agent = new HttpAgent({ host, identity });
-    if (network === 'local') {
-        await agent.fetchRootKey();
-    }
+    let agent = await getAgent(identity);
     return Actor.createActor(storageIdlFactory, {
         agent,
         canisterId: storageId,

package/dist/cache.js

@@ -2,13 +2,17 @@ import fs from 'node:fs';
 import path from 'node:path';
 import ncp from 'ncp';
 import getFolderSize from 'get-folder-size';
-import { getDependencyType, globalCacheDir, parseGithubURL } from './mops.js';
+import { getDependencyType, getNetwork, getRootDir, globalCacheDir, parseGithubURL } from './mops.js';
 import { getPackageId } from './helpers/get-package-id.js';
+let getGlobalCacheDir = () => {
+    let network = getNetwork();
+    return path.join(globalCacheDir, network === 'ic' ? '' : network);
+};
 export let show = () => {
-    return globalCacheDir;
+    return getGlobalCacheDir();
 };
 export let getDepCacheDir = (cacheName) => {
-    return path.join(globalCacheDir, 'packages', cacheName);
+    return path.join(getGlobalCacheDir(), 'packages', cacheName);
 };
 export let isDepCached = (cacheName) => {
     let dir = getDepCacheDir(cacheName);
@@ -26,7 +30,7 @@ export function getGithubDepCacheName(name, repo) {
     return `_github/${name}#${branch}` + (commitHash ? `@${commitHash}` : '');
 }
 export let addCache = (cacheName, source) => {
-    let dest = path.join(globalCacheDir, 'packages', cacheName);
+    let dest = path.join(getGlobalCacheDir(), 'packages', cacheName);
     fs.mkdirSync(dest, { recursive: true });
     return new Promise((resolve, reject) => {
         ncp.ncp(source, dest, { stopOnErr: true }, (err) => {
@@ -38,7 +42,7 @@ export let addCache = (cacheName, source) => {
     });
 };
 export let copyCache = (cacheName, dest) => {
-    let source = path.join(globalCacheDir, 'packages', cacheName);
+    let source = path.join(getGlobalCacheDir(), 'packages', cacheName);
     fs.mkdirSync(dest, { recursive: true });
     return new Promise((resolve, reject) => {
         ncp.ncp(source, dest, { stopOnErr: true }, (err) => {
@@ -50,7 +54,7 @@ export let copyCache = (cacheName, dest) => {
     });
 };
 export let cacheSize = async () => {
-    let dir = path.join(globalCacheDir);
+    let dir = path.join(getGlobalCacheDir());
     fs.mkdirSync(dir, { recursive: true });
     let size = await getFolderSize.strict(dir);
     if (size < 1024 * 1024) {
@@ -59,6 +63,11 @@ export let cacheSize = async () => {
     return (size / 1024 / 1024).toFixed(2) + ' MB';
 };
 export let cleanCache = async () => {
-    let dir = path.join(globalCacheDir);
-    fs.rmSync(dir, { recursive: true, force: true });
+    if (!getGlobalCacheDir().endsWith('mops/cache') && !getGlobalCacheDir().endsWith('/mops') && !getGlobalCacheDir().endsWith('/mops/' + getNetwork())) {
+        throw new Error('Invalid cache directory: ' + getGlobalCacheDir());
+    }
+    // local cache
+    fs.rmSync(path.join(getRootDir(), '.mops'), { recursive: true, force: true });
+    // global cache
+    fs.rmSync(getGlobalCacheDir(), { recursive: true, force: true });
 };

package/dist/cli.d.ts

@@ -1,4 +1,5 @@
 declare global {
     var MOPS_NETWORK: string;
+    var mopsReplicaTestRunning: boolean;
 }
 export {};