ic-mops 1.1.2 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Mops CLI Changelog
 
+## 1.2.0
+- Removed `mops transfer-ownership` command
+- Added `mops owner` command to manage package owners ([docs](https://docs.mops.one/cli/mops-owner))
+- Added `mops maintainers` command to manage package maintainers ([docs](https://docs.mops.one/cli/mops-maintainers))
+- Added experimental support for pocket-ic replica that comes with dfx in `mops test` command ([docs](https://docs.mops.one/cli/mops-test#--replica))
+- Added flag `--verbose` to `mops test` command to show replica logs
+- Fixed bug where `mops watch` would fail if dfx.json did not exist
+- Fixed bug with local dependencies without `mops.toml` file
+
 ## 1.1.2
 - Fixed `{MOPS_ENV}` substitution in local package path
 

package/cli.ts

@@ -21,12 +21,13 @@ import {sync} from './commands/sync.js';
 import {outdated} from './commands/outdated.js';
 import {update} from './commands/update.js';
 import {bench} from './commands/bench.js';
-import {transferOwnership} from './commands/transfer-ownership.js';
 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';
+import {addOwner, printOwners, removeOwner} from './commands/owner.js';
+import {addMaintainer, printMaintainers, removeMaintainer} from './commands/maintainer.js';
 
 declare global {
 	// eslint-disable-next-line no-var
@@ -214,6 +215,7 @@ program
 	.addOption(new Option('--mode <mode>', 'Test mode').choices(['interpreter', 'wasi', 'replica']).default('interpreter'))
 	.addOption(new Option('--replica <replica>', 'Which replica to use to run tests in replica mode').choices(['dfx', 'pocket-ic']))
 	.option('-w, --watch', 'Enable watch mode')
+	.option('--verbose', 'Verbose output')
 	.action(async (filter, options) => {
 		checkConfigFile(true);
 		await installAll({silent: true, lock: 'ignore', installFromLockFile: true});
@@ -289,6 +291,68 @@ userCommand
 
 program.addCommand(userCommand);
 
+// mops owner *
+const ownerCommand = new Command('owner').description('Package owner management');
+
+// mops owner list
+ownerCommand
+	.command('list')
+	.description('List package owners')
+	.action(async () => {
+		await printOwners();
+	});
+
+// mops owner add
+ownerCommand
+	.command('add <principal>')
+	.description('Add package owner')
+	.addOption(new Option('--yes', 'Do not ask for confirmation'))
+	.action(async (data, options) => {
+		await addOwner(data, options.yes);
+	});
+
+// mops owner remove
+ownerCommand
+	.command('remove <principal>')
+	.description('Remove package owner')
+	.addOption(new Option('--yes', 'Do not ask for confirmation'))
+	.action(async (data, options) => {
+		await removeOwner(data, options.yes);
+	});
+
+program.addCommand(ownerCommand);
+
+// mops maintainer *
+const maintainerCommand = new Command('maintainer').description('Package maintainer management');
+
+// mops maintainer list
+maintainerCommand
+	.command('list')
+	.description('List package maintainers')
+	.action(async () => {
+		await printMaintainers();
+	});
+
+// mops maintainer add
+maintainerCommand
+	.command('add <principal>')
+	.description('Add package maintainer')
+	.addOption(new Option('--yes', 'Do not ask for confirmation'))
+	.action(async (data, options) => {
+		await addMaintainer(data, options.yes);
+	});
+
+// mops maintainer remove
+maintainerCommand
+	.command('remove <principal>')
+	.description('Remove package maintainer')
+	.addOption(new Option('--yes', 'Do not ask for confirmation'))
+	.action(async (data, options) => {
+		await removeMaintainer(data, options.yes);
+	});
+
+program.addCommand(maintainerCommand);
+
 // bump
 program
 	.command('bump [major|minor|patch]')
@@ -323,14 +387,6 @@ program
 		await update(pkg, options);
 	});
 
-// transfer-ownership
-program
-	.command('transfer-ownership [to-principal]')
-	.description('Transfer ownership of the current package to another principal')
-	.action(async (toPrincipal) => {
-		await transferOwnership(toPrincipal);
-	});
-
 // toolchain
 const toolchainCommand = new Command('toolchain').description('Toolchain management');
 

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

@@ -1,5 +1,6 @@
 import process from 'node:process';
 import path from 'node:path';
+import {existsSync} from 'node:fs';
 import {createLogUpdate} from 'log-update';
 import {getRootDir, readConfig} from '../../mops.js';
 import {installDeps} from './install-deps.js';
@@ -28,10 +29,16 @@ export async function installLocalDep(pkg : string, pkgPath = '', {verbose, sile
 	// install dependencies
 	if (!ignoreTransitive) {
 		let dir = path.resolve(getRootDir(), pkgPath).replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
-		let config = readConfig(path.join(dir, 'mops.toml'));
+		let mopsToml = path.join(dir, 'mops.toml');
+
+		if (!existsSync(mopsToml)) {
+			return true;
+		}
+
+		let config = readConfig(mopsToml);
 		return installDeps(Object.values(config.dependencies || {}), {silent, verbose}, pkgPath);
 	}
 	else {
 		return true;
 	}
-}
+}

package/commands/maintainer.ts

@@ -0,0 +1,105 @@
+import process from 'node:process';
+import chalk from 'chalk';
+import {checkConfigFile, getIdentity, readConfig} from '../mops.js';
+import {mainActor} from '../api/actors.js';
+import {Principal} from '@dfinity/principal';
+import prompts from 'prompts';
+
+export async function printMaintainers() {
+	if (!checkConfigFile()) {
+		return;
+	}
+
+	let config = readConfig();
+	let actor = await mainActor();
+
+	let maintainers = await actor.getPackageMaintainers(config.package?.name || '');
+	console.log(`Maintainers of package ${chalk.bold(config.package?.name)}:`);
+	for (let maintainer of maintainers) {
+		console.log(maintainer.toText());
+	}
+}
+
+export async function addMaintainer(maintainer : string, yes = false) {
+	if (!checkConfigFile()) {
+		return;
+	}
+
+	let config = readConfig();
+	let principal = Principal.fromText(maintainer);
+
+	if (!yes) {
+		let promptsConfig = {
+			onCancel() {
+				console.log('aborted');
+				process.exit(0);
+			},
+		};
+
+		let {confirm} = await prompts({
+			type: 'confirm',
+			name: 'confirm',
+			message: `Are you sure you want to add maintainer ${chalk.yellow(maintainer)} to ${chalk.yellow(config.package?.name)} package?`,
+			initial: true,
+		}, promptsConfig);
+
+		if (!confirm) {
+			return;
+		}
+	}
+
+	let identity = await getIdentity();
+	let actor = await mainActor(identity);
+
+	let res = await actor.addMaintainer(config.package?.name || '', principal);
+	if ('ok' in res) {
+		console.log(chalk.green('Success!'));
+		console.log(`Added maintainer ${chalk.bold(maintainer)} to package ${chalk.bold(config.package?.name)}`);
+	}
+	else {
+		console.error(chalk.red('Error: ') + res.err);
+		process.exit(1);
+	}
+}
+
+export async function removeMaintainer(maintainer : string, yes = false) {
+	if (!checkConfigFile()) {
+		return;
+	}
+
+	let config = readConfig();
+	let principal = Principal.fromText(maintainer);
+
+	if (!yes) {
+		let promptsConfig = {
+			onCancel() {
+				console.log('aborted');
+				process.exit(0);
+			},
+		};
+
+		let {confirm} = await prompts({
+			type: 'confirm',
+			name: 'confirm',
+			message: `Are you sure you want to remove maintainer ${chalk.red(maintainer)} from ${chalk.red(config.package?.name)} package?`,
+			initial: true,
+		}, promptsConfig);
+
+		if (!confirm) {
+			return;
+		}
+	}
+
+	let identity = await getIdentity();
+	let actor = await mainActor(identity);
+
+	let res = await actor.removeMaintainer(config.package?.name || '', principal);
+	if ('ok' in res) {
+		console.log(chalk.green('Success!'));
+		console.log(`Removed maintainer ${chalk.bold(maintainer)} from package ${chalk.bold(config.package?.name)}`);
+	}
+	else {
+		console.error(chalk.red('Error: ') + res.err);
+		process.exit(1);
+	}
+}

package/commands/owner.ts

@@ -0,0 +1,105 @@
+import process from 'node:process';
+import chalk from 'chalk';
+import {checkConfigFile, getIdentity, readConfig} from '../mops.js';
+import {mainActor} from '../api/actors.js';
+import {Principal} from '@dfinity/principal';
+import prompts from 'prompts';
+
+export async function printOwners() {
+	if (!checkConfigFile()) {
+		return;
+	}
+
+	let config = readConfig();
+	let actor = await mainActor();
+
+	let owners = await actor.getPackageOwners(config.package?.name || '');
+	console.log(`Owners of package ${chalk.bold(config.package?.name)}:`);
+	for (let owner of owners) {
+		console.log(owner.toText());
+	}
+}
+
+export async function addOwner(owner : string, yes = false) {
+	if (!checkConfigFile()) {
+		return;
+	}
+
+	let config = readConfig();
+	let principal = Principal.fromText(owner);
+
+	if (!yes) {
+		let promptsConfig = {
+			onCancel() {
+				console.log('aborted');
+				process.exit(0);
+			},
+		};
+
+		let {confirm} = await prompts({
+			type: 'confirm',
+			name: 'confirm',
+			message: `Are you sure you want to add owner ${chalk.yellow(owner)} to ${chalk.yellow(config.package?.name)} package?`,
+			initial: true,
+		}, promptsConfig);
+
+		if (!confirm) {
+			return;
+		}
+	}
+
+	let identity = await getIdentity();
+	let actor = await mainActor(identity);
+
+	let res = await actor.addOwner(config.package?.name || '', principal);
+	if ('ok' in res) {
+		console.log(chalk.green('Success!'));
+		console.log(`Added owner ${chalk.bold(owner)} to package ${chalk.bold(config.package?.name)}`);
+	}
+	else {
+		console.error(chalk.red('Error: ') + res.err);
+		process.exit(1);
+	}
+}
+
+export async function removeOwner(owner : string, yes = false) {
+	if (!checkConfigFile()) {
+		return;
+	}
+
+	let config = readConfig();
+	let principal = Principal.fromText(owner);
+
+	if (!yes) {
+		let promptsConfig = {
+			onCancel() {
+				console.log('aborted');
+				process.exit(0);
+			},
+		};
+
+		let {confirm} = await prompts({
+			type: 'confirm',
+			name: 'confirm',
+			message: `Are you sure you want to remove owner ${chalk.red(owner)} from ${chalk.red(config.package?.name)} package?`,
+			initial: true,
+		}, promptsConfig);
+
+		if (!confirm) {
+			return;
+		}
+	}
+
+	let identity = await getIdentity();
+	let actor = await mainActor(identity);
+
+	let res = await actor.removeOwner(config.package?.name || '', principal);
+	if ('ok' in res) {
+		console.log(chalk.green('Success!'));
+		console.log(`Removed owner ${chalk.bold(owner)} from package ${chalk.bold(config.package?.name)}`);
+	}
+	else {
+		console.error(chalk.red('Error: ') + res.err);
+		process.exit(1);
+	}
+}

package/commands/replica.ts

@@ -8,19 +8,21 @@ import {spawn as spawnAsync} from 'promisify-child-process';
 import {IDL} from '@dfinity/candid';
 import {Actor, HttpAgent} from '@dfinity/agent';
 import {PocketIc, PocketIcServer} from 'pic-ic';
+import chalk from 'chalk';
 
 import {readConfig} from '../mops.js';
 import {toolchain} from './toolchain/index.js';
+import {getDfxVersion} from '../helpers/get-dfx-version.js';
 
 type StartOptions = {
-	type ?: 'dfx' | 'pocket-ic';
+	type ?: 'dfx' | 'pocket-ic' | 'dfx-pocket-ic';
 	dir ?: string;
 	verbose ?: boolean;
 	silent ?: boolean;
 };
 
 export class Replica {
-	type : 'dfx' | 'pocket-ic' = 'dfx';
+	type : 'dfx' | 'pocket-ic' | 'dfx-pocket-ic' = 'dfx';
 	verbose = false;
 	canisters : Record<string, {cwd : string; canisterId : string; actor : any; stream : PassThrough;}> = {};
 	pocketIcServer ?: PocketIcServer;
@@ -36,20 +38,33 @@ export class Replica {
 
 		silent || console.log(`Starting ${this.type} replica...`);
 
-		if (this.type == 'dfx') {
+		if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
 			fs.mkdirSync(this.dir, {recursive: true});
 			fs.writeFileSync(path.join(this.dir, 'dfx.json'), JSON.stringify(this.dfxJson(''), null, 2));
 			fs.writeFileSync(path.join(this.dir, 'canister.did'), 'service : { runTests: () -> (); }');
 
 			await this.stop();
 
-			this.dfxProcess = spawn('dfx', ['start', '--clean', '--artificial-delay', '0', (this.verbose ? '' : '-qqqq')].filter(x => x), {cwd: this.dir});
+			this.dfxProcess = spawn('dfx', ['start', this.type === 'dfx-pocket-ic' ? '--pocketic' : '', '--clean', (this.verbose ? '' : '-qqqq'), '--artificial-delay', '0'].filter(x => x).flat(), {cwd: this.dir});
 
 			// process canister logs
 			this._attachCanisterLogHandler(this.dfxProcess);
 
 			this.dfxProcess.stdout.on('data', (data) => {
-				console.log('DFX:', data.toString());
+				if (this.verbose) {
+					console.log('DFX:', data.toString());
+				}
+			});
+
+			this.dfxProcess.stderr.on('data', (data) => {
+				if (this.verbose) {
+					console.error('DFX:', data.toString());
+				}
+				if (data.toString().includes('Failed to bind socket to')) {
+					console.error(chalk.red(data.toString()));
+					console.log('Please try again after some time');
+					process.exit(11);
+				}
 			});
 
 			// await for dfx to start
@@ -115,9 +130,22 @@ export class Replica {
 	}
 
 	async stop(sigint = false) {
-		if (this.type == 'dfx') {
-			this.dfxProcess?.kill();
-			// execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), {cwd: this.dir, timeout: 10_000, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe']});
+		if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
+			if (this.dfxProcess) {
+				this.dfxProcess.kill();
+				// give replica some time to stop
+				await new Promise((resolve) => {
+					setTimeout(resolve, 1000);
+				});
+			}
+
+			// if (!this.dfxProcess) {
+			// 	try {
+			// 		execSync('dfx killall', {cwd: this.dir, timeout: 3_000, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe']});
+			//			execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), {cwd: this.dir, timeout: 10_000, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe']});
+			// 	}
+			// 	catch {}
+			// }
 		}
 		else if (this.pocketIc && this.pocketIcServer) {
 			if (!sigint) {
@@ -128,7 +156,7 @@ export class Replica {
 	}
 
 	async deploy(name : string, wasm : string, idlFactory : IDL.InterfaceFactory, cwd : string = process.cwd(), signal ?: AbortSignal) {
-		if (this.type === 'dfx') {
+		if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
 			// prepare dfx.json for current canister
 			let dfxJson = path.join(this.dir, 'dfx.json');
 
@@ -253,6 +281,7 @@ export class Replica {
 		return {
 			version: 1,
 			canisters,
+			dfx: getDfxVersion(),
 			defaults: {
 				build: {
 					packtool: 'mops sources',

package/commands/test/test.ts

@@ -8,6 +8,7 @@ import chalk from 'chalk';
 import {globSync} from 'glob';
 import chokidar from 'chokidar';
 import debounce from 'debounce';
+import {SemVer} from 'semver';
 
 import {sources} from '../sources.js';
 import {getRootDir, readConfig} from '../../mops.js';
@@ -25,6 +26,7 @@ import {Replica} from '../replica.js';
 import {ActorMethod} from '@dfinity/agent';
 import {PassThrough, Readable} from 'node:stream';
 import {TestMode} from '../../types.js';
+import {getDfxVersion} from '../../helpers/get-dfx-version.js';
 
 let ignore = [
 	'**/node_modules/**',
@@ -39,13 +41,14 @@ let globConfig = {
 };
 
 type ReporterName = 'verbose' | 'files' | 'compact' | 'silent';
-type ReplicaName = 'dfx' | 'pocket-ic';
+type ReplicaName = 'dfx' | 'pocket-ic' | 'dfx-pocket-ic';
 
 type TestOptions = {
 	watch : boolean;
 	reporter : ReporterName;
 	mode : TestMode;
 	replica : ReplicaName;
+	verbose : boolean;
 };
 
 
@@ -66,7 +69,20 @@ export async function test(filter = '', options : Partial<TestOptions> = {}) {
 	let rootDir = getRootDir();
 
 	let replicaType = options.replica ?? (config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx' as ReplicaName);
+
+	if (replicaType === 'pocket-ic' && !config.toolchain?.['pocket-ic']) {
+		let dfxVersion = getDfxVersion();
+		if (!dfxVersion || new SemVer(dfxVersion).compare('0.24.1') < 0) {
+			console.log(chalk.red('Please update dfx to the version >=0.24.1 or specify pocket-ic version in mops.toml'));
+			process.exit(1);
+		}
+		else {
+			replicaType = 'dfx-pocket-ic';
+		}
+	}
+
 	replica.type = replicaType;
+	replica.verbose = !!options.verbose;
 
 	if (options.watch) {
 		replica.ttl = 60 * 15; // 15 minutes
@@ -202,6 +218,7 @@ export async function testWithReporter(reporterName : ReporterName | Reporter |
 	let testTempDir = path.join(getRootDir(), '.mops/.test/');
 	replica.dir = testTempDir;
 
+	fs.rmSync(testTempDir, {recursive: true, force: true});
 	fs.mkdirSync(testTempDir, {recursive: true});
 
 	await parallel(os.cpus().length, files, async (file : string) => {

package/commands/watch/parseDfxJson.ts

@@ -51,14 +51,14 @@ function readDfxJson() : DfxConfig | Record<string, never> {
 
 export function getMotokoCanisters() : Record<string, string> {
 	let dfxJson = readDfxJson();
-	return Object.fromEntries(Object.entries(dfxJson.canisters)
+	return Object.fromEntries(Object.entries(dfxJson.canisters || {})
 		.filter(([_, canister]) => canister.type === 'motoko')
 		.map(([name, canister]) => [name, canister.main ?? '']));
 }
 
 export function getMotokoCanistersWithDeclarations() : Record<string, string> {
 	let dfxJson = readDfxJson();
-	return Object.fromEntries(Object.entries(dfxJson.canisters)
+	return Object.fromEntries(Object.entries(dfxJson.canisters || {})
 		.filter(([_, canister]) => canister.type === 'motoko' && canister.declarations)
 		.map(([name, canister]) => [name, canister.main ?? '']));
 }