ic-mops 0.36.1 → 0.37.0-pre.0

package/bin/moc-wrapper.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+
+# FILE_NAME=$(basename "$0");
+
+# function findMopsTomlFile() {
+#   if [ -f "mops.toml" ]; then
+#     printf '%s\n' "${PWD%/}/mops.toml"
+#   elif [ "$PWD" = / ]; then
+#     false
+#   else
+#     # a subshell so that we don't affect the caller's $PWD
+#     (cd .. && findMopsTomlFile "mops.toml")
+#   fi
+# }
+
+# mopsTomlFile="$(findMopsTomlFile)"
+
+# cat $mopsTomlFile
+
+# mocPath=""
+# if [ -z "$mopsTomlFile" ]
+# then
+#   mocPath="$HOME/.cache/mocv/versions/$(cat $HOME/.cache/mocv/versions/current/version.txt)/$FILE_NAME"
+#   # mocPath="$(DFX_WARNING=-version_check dfx cache show)/$FILE_NAME"
+# else
+#   mocPath="$HOME/.cache/mocv/versions/$(cat $mopsTomlFile)/$FILE_NAME"
+# fi
+
+# fallback to dfx
+# mocPath="$(DFX_WARNING=-version_check dfx cache show)/moc"
+
+# echo $mocPath
+
+# # install moc version if not installed yet
+# if [[ ! -f "$mocPath" && -f "$mopsTomlFile" ]]; then
+#   # mocv install --silent $(cat $mopsTomlFile)
+#   mocv use $(cat $mopsTomlFile)
+# fi
+
+# mocPath="/home/zen/.cache/mocv/versions/current/moc"
+
+# mocPath=""
+# if command -v mops &> /dev/null
+# then
+#   mocPath="/home/zen/.cache/mops/moc/0.9.5/moc"
+# else
+#   mocPath="$(DFX_WARNING=-version_check dfx cache show)/moc" # fallback to dfx
+# fi
+
+mocPath="$(mops toolchain bin moc)"
+# mocPath="$(dfx cache show)/moc"
+# mocPath="/home/zen/.cache/mops/moc/0.7.5/moc"
+
+$mocPath "$@"

package/bin/mops.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../cli.js';

package/cli.ts

@@ -1,7 +1,5 @@
-#!/usr/bin/env node
-
 import fs from 'node:fs';
-import {program, Argument, Option} from 'commander';
+import {Command, Argument, Option} from 'commander';
 import chalk from 'chalk';
 
 import {init} from './commands/init.js';
@@ -26,6 +24,7 @@ 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 {docs} from './commands/docs.js';
 
 declare global {
@@ -38,6 +37,7 @@ if (fs.existsSync(networkFile)) {
 	globalThis.MOPS_NETWORK = fs.readFileSync(networkFile).toString() || 'ic';
 }
 
+let program = new Command();
 
 program.name('mops');
 
@@ -58,7 +58,7 @@ program
 program
 	.command('add <pkg>')
 	.description('Install the package and save it to mops.toml')
-	.option('--dev')
+	.option('--dev', 'Add to [dev-dependencies] section')
 	.option('--verbose')
 	.addOption(new Option('--lock <action>', 'Lockfile action').choices(['update', 'ignore']))
 	.action(async (pkg, options) => {
@@ -328,4 +328,40 @@ program
 		await transferOwnership(toPrincipal);
 	});
 
+// toolchain
+const toolchainCommand = new Command('toolchain').description('Toolchain management');
+
+toolchainCommand
+	.command('init')
+	.description('One-time initialization of toolchain management')
+	.action(async () => {
+		toolchain.init();
+	});
+
+toolchainCommand
+	.command('reset')
+	.description('Uninstall toolchain management')
+	.action(async () => {
+		toolchain.init({reset: true});
+	});
+
+toolchainCommand
+	.command('use')
+	.description('Install specified tool version and update mops.toml')
+	.addArgument(new Argument('<tool>').choices(['moc', 'wasmtime', 'pocket-ic']))
+	.addArgument(new Argument('<version>'))
+	.action(async (tool, version) => {
+		toolchain.use(tool, version);
+	});
+
+toolchainCommand
+	.command('bin')
+	.description('Get path to the tool binary\n<tool> can be one of "moc", "wasmtime", "pocket-ic"')
+	.addArgument(new Argument('<tool>').choices(['moc', 'wasmtime', 'pocket-ic']))
+	.action(async (tool) => {
+		toolchain.bin(tool);
+	});
+
+program.addCommand(toolchainCommand);
+
 program.parse();

package/commands/toolchain/index.ts

@@ -0,0 +1,153 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import {execSync} from 'node:child_process';
+import {getClosestConfigFile, globalCacheDir, readConfig, writeConfig} from '../../mops.js';
+import * as moc from './moc.js';
+import {Tool} from '../../types.js';
+import chalk from 'chalk';
+
+
+// update shell config files to set DFX_MOC_PATH to moc-wrapper
+async function init({reset = false} = {}) {
+	if (process.platform == 'win32') {
+		console.error('Windows is not supported. Please use WSL');
+		process.exit(1);
+	}
+
+	try {
+		let res = execSync('which mocv').toString().trim();
+		if (res) {
+			console.error('Mops is not compatible with mocv. Please uninstall mocv and try again.');
+			console.log('Steps to uninstall mocv:');
+			console.log('1. Run "mocv reset"');
+			console.log('2. Run "npm uninstall -g mocv"');
+			process.exit(1);
+		}
+	}
+	catch {}
+
+	let zshrc = path.join(os.homedir(), '.zshrc');
+	let bashrc = path.join(os.homedir(), '.bashrc');
+
+	let shellConfigFiles = [bashrc, zshrc].filter((file) => {
+		return fs.existsSync(file);
+	});
+
+	if (shellConfigFiles.length === 0) {
+		console.error('Shell config files not found: ".bashrc" or ".zshrc"');
+		process.exit(1);
+	}
+
+	// update all existing shell config files
+	for (let configFile of shellConfigFiles) {
+		let text = fs.readFileSync(configFile).toString();
+		let setDfxLine = '\nexport DFX_MOC_PATH="moc-wrapper"';
+
+		let newLines = [
+			setDfxLine,
+		];
+
+		let oldLines = [
+			// legacy mocv lines
+			`\nexport DFX_MOC_PATH=${path.join(path.join(os.homedir(), '.cache/mocv'), 'versions/current')}/moc`,
+			'\nexport DFX_MOC_PATH="$HOME/.cache/mocv/versions/current/moc"',
+			// new
+			setDfxLine,
+		];
+
+		// remove old lines
+		for (let oldLine of oldLines) {
+			text = text.replace(oldLine, '');
+		}
+
+		if (text.endsWith('\n\n')) {
+			text = text.trimEnd() + '\n';
+		}
+
+		// insert new lines
+		if (!reset) {
+			if (!text.endsWith('\n')) {
+				text += '\n';
+			}
+			for (let newLine of newLines) {
+				text += newLine;
+			}
+			text += '\n';
+		}
+
+		fs.writeFileSync(configFile, text);
+	}
+
+	console.log(chalk.green('Success!'));
+}
+
+async function download(tool: Tool, version: string) {
+	if (tool === 'moc') {
+		await moc.download(version);
+	}
+}
+
+// async function downloadAll() {
+// 	let config = readConfig();
+// 	if (config.toolchain?.moc) {
+// 		await download('moc', config.toolchain.moc);
+// 	}
+// 	if (config.toolchain?.wasmtime) {
+// 		await download('wasmtime', config.toolchain.wasmtime);
+// 	}
+// 	if (config.toolchain?.['pocket-ic']) {
+// 		await download('pocket-ic', config.toolchain['pocket-ic']);
+// 	}
+// }
+
+// download binary and set version in mops.toml
+async function use(tool: Tool, version: string) {
+	await download(tool, version);
+
+	let config = readConfig();
+	config.toolchain = config.toolchain || {};
+	config.toolchain[tool] = version;
+	writeConfig(config);
+}
+
+// return current version from mops.toml
+async function bin(tool: Tool) {
+	let hasConfig = getClosestConfigFile();
+
+	// fallback to dfx moc
+	if (!hasConfig) {
+		console.log(execSync('dfx cache show').toString().trim() + '/moc');
+		return;
+	}
+
+	let config = readConfig();
+	let version = config.toolchain?.[tool];
+
+	if (!version) {
+		// fallback to dfx moc
+		if (tool === 'moc') {
+			console.log(execSync('dfx cache show').toString().trim() + '/moc');
+			return;
+		}
+		console.error(`Toolchain '${tool}' is not defined in mops.toml`);
+		process.exit(1);
+	}
+
+	if (version) {
+		await download(tool, version);
+
+		if (tool === 'moc') {
+			console.log(path.join(globalCacheDir, 'moc', version, 'moc'));
+		}
+		else {
+			console.log(path.join(globalCacheDir, tool, version, 'moc'));
+		}
+	}
+}
+
+export let toolchain = {
+	init,
+	use,
+	bin,
+};

package/commands/toolchain/moc.ts

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+
+import {globalCacheDir} from '../../mops.js';
+import {downloadAndExtract} from './toolchain-utils.js';
+
+let cacheDir = path.join(globalCacheDir, 'moc');
+
+export let isCached = (version: string) => {
+	let dir = path.join(cacheDir, version);
+	return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'moc'));
+};
+
+export let download = async (version: string, {silent = false} = {}) => {
+	if (process.platform == 'win32') {
+		console.error('Windows is not supported. Please use WSL');
+		process.exit(1);
+	}
+	if (!version) {
+		console.error('version is not defined');
+		process.exit(1);
+	}
+	if (isCached(version)) {
+		return;
+	}
+
+	let url;
+	if (parseInt(version.replaceAll('.', '')) >= parseInt('0.9.5'.replaceAll('.', ''))) {
+		let platfrom = process.platform == 'darwin' ? 'Darwin' : 'Linux';
+		let arch = process.arch.startsWith('arm') ? 'arm64' : 'x86_64';
+		// currently only x64 binaries are available
+		arch = 'x86_64';
+		url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+	}
+	else {
+		let platfrom = process.platform == 'darwin' ? 'macos' : 'linux64';
+		url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
+	}
+
+	silent || console.log(`Downloading ${url}`);
+
+	await downloadAndExtract(url, path.join(cacheDir, version));
+};

package/commands/toolchain/mocv.ts

@@ -0,0 +1,313 @@
+// @ts-nocheck
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import tar from 'tar';
+import {program} from 'commander';
+import prompts from 'prompts';
+import {Octokit} from 'octokit';
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+
+if (process.platform == 'win32') {
+	console.log('Windows is not supported. Please use WSL');
+	process.exit(1);
+}
+
+let zshrc = path.join(os.homedir(), '.zshrc');
+let bashrc = path.join(os.homedir(), '.bashrc');
+let cacheDir = path.join(os.homedir(), '.cache/mocv');
+let curVersionFile = path.join(cacheDir, 'versions/current/version.txt');
+let tmpDir = path.join(cacheDir, '.tmp');
+let file = path.join(tmpDir, 'moc.tar.gz');
+
+let download = async (version: string, {silent = false} = {}) => {
+	if (!version) {
+		console.log('version is not defined');
+		process.exit(1);
+	}
+	if (isCached(version)) {
+		return;
+	}
+
+
+	let url;
+	if (parseInt(version.replaceAll('.', '')) >= parseInt('0.9.5'.replaceAll('.', ''))) {
+		let platfrom = process.platform == 'darwin' ? 'Darwin' : 'Linux';
+		let arch = process.arch.startsWith('arm') ? 'arm64' : 'x86_64';
+		// currently only x64 binaries are available
+		arch = 'x86_64';
+		url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+	}
+	else {
+		let platfrom = process.platform == 'darwin' ? 'macos' : 'linux64';
+		url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
+	}
+
+	silent || console.log(`Downloading ${url}`);
+
+	let res = await fetch(url);
+
+	if (res.status !== 200) {
+		console.log(`ERR ${res.status} ${url}`);
+		console.log(`moc version '${version}' not found`);
+		process.exit(1);
+	}
+
+	let arrayBuffer = await res.arrayBuffer();
+	let buffer = Buffer.from(arrayBuffer);
+
+	fs.mkdirSync(tmpDir, {recursive: true});
+	fs.writeFileSync(file, buffer);
+
+	let verDir = path.join(cacheDir, 'versions', version);
+	fs.mkdirSync(verDir, {recursive: true});
+	await tar.extract({
+		file,
+		cwd: verDir,
+	});
+
+	fs.rmSync(file);
+};
+
+let isCached = (version: string) => {
+	let dir = path.join(cacheDir, 'versions', version);
+	return fs.existsSync(path.join(dir, 'moc'))
+		&& fs.existsSync(path.join(dir, 'mo-doc'))
+		&& fs.existsSync(path.join(dir, 'mo-ide'));
+};
+
+let setCurrent = (version: string) => {
+	fs.copySync(path.join(cacheDir, 'versions', version), path.join(cacheDir, 'versions/current'), {recursive: true});
+	fs.writeFileSync(curVersionFile, version);
+};
+
+let getCurrent = () => {
+	if (fs.existsSync(curVersionFile)) {
+		return fs.readFileSync(curVersionFile).toString();
+	}
+};
+
+let getLatest = async () => {
+	let releases = await getReleases();
+	return releases[0].tag_name;
+};
+
+let getReleases = async () => {
+	let octokit = new Octokit;
+	let res = await octokit.request('GET /repos/dfinity/motoko/releases', {
+		per_page: 10,
+		headers: {
+			'X-GitHub-Api-Version': '2022-11-28'
+		}
+	});
+	if (res.status !== 200) {
+		console.log('Releases fetch error');
+		process.exit(1);
+	}
+	return res.data;
+};
+
+let use = async (version: string) => {
+	if (version === 'latest') {
+		version = await getLatest();
+	}
+	await download(version);
+	setCurrent(version);
+	console.log(`Selected moc ${version}`);
+
+	// update github env
+	if (process.env.GITHUB_ENV) {
+		fs.appendFileSync(process.env.GITHUB_ENV, `DFX_MOC_PATH=${path.join(cacheDir, 'versions', version)}/moc\n`);
+	}
+};
+
+program.name('mocv')
+	.action(async (_, config) => {
+		if (config.args.length) {
+			console.log(`unknown command '${config.args.join(' ')}'`);
+			process.exit(1);
+		}
+		let releases = await getReleases();
+		let versions = releases.map((item: {tag_name: any;}) => item.tag_name);
+		let current = getCurrent();
+		let currentIndex = versions.indexOf(current);
+
+		let res = await prompts({
+			type: 'select',
+			name: 'version',
+			message: 'Select moc version',
+			choices: releases.map((release: {published_at: string | number | Date; tag_name: string;}, i: any) => {
+				let date = new Date(release.published_at).toLocaleDateString(undefined, {year: 'numeric', month: 'short', day: 'numeric'});
+				return {
+					title: release.tag_name + chalk.gray(`  ${date}${currentIndex === i ? chalk.italic(' (current)') : ''}`),
+					value: release.tag_name,
+				};
+			}),
+			initial: currentIndex == -1 ? 0 : currentIndex,
+		});
+
+		if (!res.version) {
+			return;
+		}
+
+		await use(res.version);
+	});
+
+let updateShellConfig = async ({reset = false, yes = false} = {}) => {
+	let setDfxMocPath = reset || yes;
+	let updatePath = reset || yes;
+
+	if (!setDfxMocPath) {
+		let res = await prompts({
+			type: 'select',
+			name: 'setDfxMocPath',
+			message: 'Do you want to set DFX_MOC_PATH, so `dfx` will use the current `moc` version?',
+			choices: [
+				{
+					title: 'Yes',
+					value: true,
+				},
+				{
+					title: 'No',
+					value: false,
+				},
+			],
+		});
+		setDfxMocPath = res.setDfxMocPath;
+	}
+
+	if (!updatePath) {
+		let res = await prompts({
+			type: 'select',
+			name: 'updatePath',
+			message: 'Do you want to update PATH, so you can call `moc`, `mo-doc` and `mo-ide` from the terminal?',
+			choices: [
+				{
+					title: 'Yes',
+					value: true,
+				},
+				{
+					title: 'No',
+					value: false,
+				},
+			],
+		});
+		updatePath = res.updatePath;
+	}
+
+	if (!setDfxMocPath && !updatePath) {
+		console.log('Nothing to do');
+		return;
+	}
+
+	let configFiles = [];
+	if (reset || yes) {
+		configFiles = [bashrc, zshrc];
+	}
+	else {
+		let {configFile} = await prompts({
+			type: 'select',
+			name: 'configFile',
+			message: 'Select your shell config file',
+			choices: [
+				{
+					title: bashrc,
+					value: bashrc,
+				},
+				{
+					title: zshrc,
+					value: zshrc,
+				},
+			],
+		});
+		configFiles = [configFile];
+	}
+
+	for (let configFile of configFiles) {
+		if (!fs.existsSync(configFile)) {
+			console.log(`${configFile} not found`);
+			process.exit(1);
+		}
+
+		let data = fs.readFileSync(configFile).toString();
+		let setDfxLine = '\nexport DFX_MOC_PATH="$HOME/.cache/mocv/versions/current/moc"';
+		let updatePathLine = '\nPATH="$HOME/.cache/mocv/versions/current:$PATH"';
+
+		let newLines = [];
+		setDfxMocPath && newLines.push(setDfxLine);
+		updatePath && newLines.push(updatePathLine);
+
+		let oldLines = [
+			`\nexport DFX_MOC_PATH=${path.join(cacheDir, 'versions/current')}/moc\n`,
+			setDfxLine,
+			updatePathLine,
+		];
+		for (let oldLine of oldLines) {
+			data = data.replace(oldLine, '');
+		}
+
+		if (data.endsWith('\n\n')) {
+			data = data.trimEnd() + '\n';
+		}
+
+		if (!reset) {
+			if (!data.endsWith('\n')) {
+				data += '\n';
+			}
+			for (let newLine of newLines) {
+				data += newLine;
+			}
+			data += '\n';
+		}
+
+		fs.writeFileSync(configFile, data);
+	};
+
+	console.log('Success!');
+	// console.log(`Run "source ${configFile}" to apply changes`);
+	console.log('Restart terminal to apply changes');
+};
+
+program.command('init')
+	.description('mocv one time initialization')
+	.option('-y, --yes', 'Skip prompts')
+	.action(async (options) => {
+		updateShellConfig(options);
+	});
+
+program.command('reset')
+	.description('Reset changes made by `mocv init`')
+	.action(async () => {
+		updateShellConfig({reset: true});
+	});
+
+program.command('use <version>')
+	.description('Set current moc version.\nExample 1: "mocv use 0.8.4"\nExample 2: "mocv use latest"')
+	.action(async (version) => {
+		await use(version);
+	});
+
+program.command('current')
+	.description('Print current moc version')
+	.action(async () => {
+		console.log(getCurrent());
+	});
+
+program.command('bin [version]')
+	.description('Print bin directory')
+	.action(async (version = getCurrent()) => {
+		if (version === 'latest') {
+			version = await getLatest();
+		}
+		if (!version) {
+			console.log('No version selected. Please pass a version arg or run `mocv` or `mocv use <version>`');
+			process.exit(1);
+		}
+		if (!isCached(version)) {
+			await download(version, {silent: true});
+		}
+		console.log(path.join(cacheDir, 'versions', version));
+	});
+
+program.parse();

package/commands/toolchain/pocket-ic.ts

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import fs from 'node:fs';
+
+import {globalCacheDir} from '../../mops.js';
+import {downloadAndExtract} from './toolchain-utils.js';
+
+let cacheDir = path.join(globalCacheDir, 'pocket-ic');
+
+export let isCached = (version: string) => {
+	let dir = path.join(cacheDir, version);
+	return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'pocket-ic'));
+};
+
+export let download = async (version: string, {silent = false} = {}) => {
+	if (!version) {
+		console.error('version is not defined');
+		process.exit(1);
+	}
+	if (isCached(version)) {
+		return;
+	}
+
+	let platfrom = process.platform == 'darwin' ? 'darwin' : 'linux';
+	let arch = 'x86_64';
+
+	let hashes: Record<string, string> = {
+		'2.0.1': '69e1408347723dbaa7a6cd2faa9b65c42abbe861',
+		'2.0.0': '29ec86dc9f9ca4691d4d4386c8b2aa41e14d9d16',
+		'1.0.0': '307d5847c1d2fe1f5e19181c7d0fcec23f4658b3',
+	};
+
+	let url = `https://download.dfinity.systems/ic/${hashes[version]}/openssl-static-binaries/${arch}-${platfrom}/pocket-ic.gz`;
+
+	silent || console.log(`Downloading ${url}`);
+
+	await downloadAndExtract(url, path.join(cacheDir, version));
+};

package/commands/toolchain/toolchain-utils.ts

@@ -0,0 +1,74 @@
+import path from 'node:path';
+import {unzipSync} from 'node:zlib';
+import {chmodSync} from 'node:fs';
+import fs from 'fs-extra';
+import decompress from 'decompress';
+import decompressTarxz from 'decomp-tarxz';
+import {deleteSync} from 'del';
+import {Octokit} from 'octokit';
+import tar from 'tar';
+
+import {getRootDir} from '../../mops.js';
+
+export let downloadAndExtract = async (url: string, dest: string) => {
+	let res = await fetch(url);
+
+	if (res.status !== 200) {
+		console.error(`ERROR ${res.status} ${url}`);
+		process.exit(1);
+	}
+
+	let arrayBuffer = await res.arrayBuffer();
+	let buffer = Buffer.from(arrayBuffer);
+
+	let tmpDir = path.join(getRootDir(), '.mops', '_tmp');
+	let archive = path.join(tmpDir, path.basename(url));
+
+	fs.mkdirSync(tmpDir, {recursive: true});
+	fs.writeFileSync(archive, buffer);
+
+	fs.mkdirSync(dest, {recursive: true});
+
+	if (archive.endsWith('.xz')) {
+		await decompress(archive, dest, {
+			strip: 1,
+			plugins: [decompressTarxz()],
+		}).catch(() => {
+			deleteSync([tmpDir]);
+		});
+	}
+	else if (archive.endsWith('tar.gz')) {
+		await tar.extract({
+			file: archive,
+			cwd: dest,
+		});
+	}
+	else if (archive.endsWith('.gz')) {
+		let destFile = path.join(dest, path.parse(archive).name);
+		fs.writeFileSync(destFile, unzipSync(buffer));
+		chmodSync(destFile, 0o700);
+	}
+
+	deleteSync([tmpDir], {force: true});
+};
+
+export let getLatestReleaseTag = async (repo: string): Promise<string | undefined> => {
+	let releases = await getReleases(repo);
+	let release = releases.find((release: any) => !release.prerelease && !release.draft);
+	return release?.tag_name;
+};
+
+export let getReleases = async (repo: string) => {
+	let octokit = new Octokit;
+	let res = await octokit.request(`GET /repos/${repo}/releases`, {
+		per_page: 10,
+		headers: {
+			'X-GitHub-Api-Version': '2022-11-28'
+		}
+	});
+	if (res.status !== 200) {
+		console.log('Releases fetch error');
+		process.exit(1);
+	}
+	return res.data;
+};

package/commands/toolchain/wasmtime.ts

@@ -0,0 +1,30 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+
+import {globalCacheDir} from '../../mops.js';
+import {downloadAndExtract} from './toolchain-utils.js';
+
+let cacheDir = path.join(globalCacheDir, 'wasmtime');
+
+export let isCached = (version: string) => {
+	let dir = path.join(cacheDir, version);
+	return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'wasmtime'));
+};
+
+export let download = async (version: string, {silent = false} = {}) => {
+	if (!version) {
+		console.error('version is not defined');
+		process.exit(1);
+	}
+	if (isCached(version)) {
+		return;
+	}
+
+	let platfrom = process.platform == 'darwin' ? 'macos' : 'linux';
+	let arch = process.arch.startsWith('arm') ? 'aarch64' : 'x86_64';
+	let url = `https://github.com/bytecodealliance/wasmtime/releases/download/v${version}/wasmtime-v${version}-${arch}-${platfrom}.tar.xz`;
+
+	silent || console.log(`Downloading ${url}`);
+
+	await downloadAndExtract(url, path.join(cacheDir, version));
+};

package/dist/bin/mops.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import '../cli.js';

package/dist/cli.d.ts

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 declare global {
     var MOPS_NETWORK: string;
 }

package/dist/cli.js

@@ -1,6 +1,5 @@
-#!/usr/bin/env node
 import fs from 'node:fs';
-import { program, Argument, Option } from 'commander';
+import { Command, Argument, Option } from 'commander';
 import chalk from 'chalk';
 import { init } from './commands/init.js';
 import { publish } from './commands/publish.js';
@@ -24,10 +23,12 @@ 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';
 let networkFile = getNetworkFile();
 if (fs.existsSync(networkFile)) {
     globalThis.MOPS_NETWORK = fs.readFileSync(networkFile).toString() || 'ic';
 }
+let program = new Command();
 program.name('mops');
 // --version
 let packageJson = JSON.parse(fs.readFileSync(new URL('package.json', import.meta.url)).toString());
@@ -44,7 +45,7 @@ program
 program
     .command('add <pkg>')
     .description('Install the package and save it to mops.toml')
-    .option('--dev')
+    .option('--dev', 'Add to [dev-dependencies] section')
     .option('--verbose')
     .addOption(new Option('--lock <action>', 'Lockfile action').choices(['update', 'ignore']))
     .action(async (pkg, options) => {
@@ -290,4 +291,34 @@ program
     .action(async (toPrincipal) => {
     await transferOwnership(toPrincipal);
 });
+// toolchain
+const toolchainCommand = new Command('toolchain').description('Toolchain management');
+toolchainCommand
+    .command('init')
+    .description('One-time initialization of toolchain management')
+    .action(async () => {
+    toolchain.init();
+});
+toolchainCommand
+    .command('reset')
+    .description('Uninstall toolchain management')
+    .action(async () => {
+    toolchain.init({ reset: true });
+});
+toolchainCommand
+    .command('use')
+    .description('Install specified tool version and update mops.toml')
+    .addArgument(new Argument('<tool>').choices(['moc', 'wasmtime', 'pocket-ic']))
+    .addArgument(new Argument('<version>'))
+    .action(async (tool, version) => {
+    toolchain.use(tool, version);
+});
+toolchainCommand
+    .command('bin')
+    .description('Get path to the tool binary\n<tool> can be one of "moc", "wasmtime", "pocket-ic"')
+    .addArgument(new Argument('<tool>').choices(['moc', 'wasmtime', 'pocket-ic']))
+    .action(async (tool) => {
+    toolchain.bin(tool);
+});
+program.addCommand(toolchainCommand);
 program.parse();

package/dist/commands/toolchain/index.d.ts

@@ -0,0 +1,12 @@
+import { Tool } from '../../types.js';
+declare function init({ reset }?: {
+    reset?: boolean | undefined;
+}): Promise<void>;
+declare function use(tool: Tool, version: string): Promise<void>;
+declare function bin(tool: Tool): Promise<void>;
+export declare let toolchain: {
+    init: typeof init;
+    use: typeof use;
+    bin: typeof bin;
+};
+export {};

package/dist/commands/toolchain/index.js

@@ -0,0 +1,127 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { execSync } from 'node:child_process';
+import { getClosestConfigFile, globalCacheDir, readConfig, writeConfig } from '../../mops.js';
+import * as moc from './moc.js';
+import chalk from 'chalk';
+// update shell config files to set DFX_MOC_PATH to moc-wrapper
+async function init({ reset = false } = {}) {
+    if (process.platform == 'win32') {
+        console.error('Windows is not supported. Please use WSL');
+        process.exit(1);
+    }
+    try {
+        let res = execSync('which mocv').toString().trim();
+        if (res) {
+            console.error('Mops is not compatible with mocv. Please uninstall mocv and try again.');
+            console.log('Steps to uninstall mocv:');
+            console.log('1. Run "mocv reset"');
+            console.log('2. Run "npm uninstall -g mocv"');
+            process.exit(1);
+        }
+    }
+    catch { }
+    let zshrc = path.join(os.homedir(), '.zshrc');
+    let bashrc = path.join(os.homedir(), '.bashrc');
+    let shellConfigFiles = [bashrc, zshrc].filter((file) => {
+        return fs.existsSync(file);
+    });
+    if (shellConfigFiles.length === 0) {
+        console.error('Shell config files not found: ".bashrc" or ".zshrc"');
+        process.exit(1);
+    }
+    // update all existing shell config files
+    for (let configFile of shellConfigFiles) {
+        let text = fs.readFileSync(configFile).toString();
+        let setDfxLine = '\nexport DFX_MOC_PATH="moc-wrapper"';
+        let newLines = [
+            setDfxLine,
+        ];
+        let oldLines = [
+            // legacy mocv lines
+            `\nexport DFX_MOC_PATH=${path.join(path.join(os.homedir(), '.cache/mocv'), 'versions/current')}/moc`,
+            '\nexport DFX_MOC_PATH="$HOME/.cache/mocv/versions/current/moc"',
+            // new
+            setDfxLine,
+        ];
+        // remove old lines
+        for (let oldLine of oldLines) {
+            text = text.replace(oldLine, '');
+        }
+        if (text.endsWith('\n\n')) {
+            text = text.trimEnd() + '\n';
+        }
+        // insert new lines
+        if (!reset) {
+            if (!text.endsWith('\n')) {
+                text += '\n';
+            }
+            for (let newLine of newLines) {
+                text += newLine;
+            }
+            text += '\n';
+        }
+        fs.writeFileSync(configFile, text);
+    }
+    console.log(chalk.green('Success!'));
+}
+async function download(tool, version) {
+    if (tool === 'moc') {
+        await moc.download(version);
+    }
+}
+// async function downloadAll() {
+// 	let config = readConfig();
+// 	if (config.toolchain?.moc) {
+// 		await download('moc', config.toolchain.moc);
+// 	}
+// 	if (config.toolchain?.wasmtime) {
+// 		await download('wasmtime', config.toolchain.wasmtime);
+// 	}
+// 	if (config.toolchain?.['pocket-ic']) {
+// 		await download('pocket-ic', config.toolchain['pocket-ic']);
+// 	}
+// }
+// download binary and set version in mops.toml
+async function use(tool, version) {
+    await download(tool, version);
+    let config = readConfig();
+    config.toolchain = config.toolchain || {};
+    config.toolchain[tool] = version;
+    writeConfig(config);
+}
+// return current version from mops.toml
+async function bin(tool) {
+    let hasConfig = getClosestConfigFile();
+    // fallback to dfx moc
+    if (!hasConfig) {
+        console.log(execSync('dfx cache show').toString().trim() + '/moc');
+        return;
+    }
+    let config = readConfig();
+    let version = config.toolchain?.[tool];
+    if (!version) {
+        // fallback to dfx moc
+        if (tool === 'moc') {
+            console.log(execSync('dfx cache show').toString().trim() + '/moc');
+            return;
+        }
+        console.error(`Toolchain '${tool}' is not defined in mops.toml`);
+        process.exit(1);
+    }
+    if (version) {
+        await download(tool, version);
+        if (tool === 'moc') {
+            console.log(path.join(globalCacheDir, 'moc', version, 'moc'));
+        }
+        else {
+            console.log(path.join(globalCacheDir, tool, version, 'moc'));
+        }
+    }
+}
+export let toolchain = {
+    init,
+    use,
+    bin,
+};

package/dist/commands/toolchain/moc.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import { globalCacheDir } from '../../mops.js';
-import { downloadGithubRelease } from './toolchain-utils.js';
+import { downloadAndExtract } from './toolchain-utils.js';
 let cacheDir = path.join(globalCacheDir, 'moc');
 export let isCached = (version) => {
     let dir = path.join(cacheDir, version);
@@ -9,11 +9,11 @@ export let isCached = (version) => {
 };
 export let download = async (version, { silent = false } = {}) => {
     if (process.platform == 'win32') {
-        console.log('Windows is not supported. Please use WSL');
+        console.error('Windows is not supported. Please use WSL');
         process.exit(1);
     }
     if (!version) {
-        console.log('version is not defined');
+        console.error('version is not defined');
         process.exit(1);
     }
     if (isCached(version)) {
@@ -32,5 +32,5 @@ export let download = async (version, { silent = false } = {}) => {
         url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
     }
     silent || console.log(`Downloading ${url}`);
-    await downloadGithubRelease(url, path.join(cacheDir, version));
+    await downloadAndExtract(url, path.join(cacheDir, version));
 };

package/dist/commands/toolchain/pocket-ic.d.ts

@@ -0,0 +1,4 @@
+export declare let isCached: (version: string) => boolean;
+export declare let download: (version: string, { silent }?: {
+    silent?: boolean | undefined;
+}) => Promise<void>;

package/dist/commands/toolchain/pocket-ic.js

@@ -0,0 +1,28 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { globalCacheDir } from '../../mops.js';
+import { downloadAndExtract } from './toolchain-utils.js';
+let cacheDir = path.join(globalCacheDir, 'pocket-ic');
+export let isCached = (version) => {
+    let dir = path.join(cacheDir, version);
+    return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'pocket-ic'));
+};
+export let download = async (version, { silent = false } = {}) => {
+    if (!version) {
+        console.error('version is not defined');
+        process.exit(1);
+    }
+    if (isCached(version)) {
+        return;
+    }
+    let platfrom = process.platform == 'darwin' ? 'darwin' : 'linux';
+    let arch = 'x86_64';
+    let hashes = {
+        '2.0.1': '69e1408347723dbaa7a6cd2faa9b65c42abbe861',
+        '2.0.0': '29ec86dc9f9ca4691d4d4386c8b2aa41e14d9d16',
+        '1.0.0': '307d5847c1d2fe1f5e19181c7d0fcec23f4658b3',
+    };
+    let url = `https://download.dfinity.systems/ic/${hashes[version]}/openssl-static-binaries/${arch}-${platfrom}/pocket-ic.gz`;
+    silent || console.log(`Downloading ${url}`);
+    await downloadAndExtract(url, path.join(cacheDir, version));
+};

package/dist/commands/toolchain/toolchain-utils.d.ts

@@ -1,3 +1,3 @@
-export declare let downloadGithubRelease: (url: string, dest: string) => Promise<void>;
+export declare let downloadAndExtract: (url: string, dest: string) => Promise<void>;
 export declare let getLatestReleaseTag: (repo: string) => Promise<string | undefined>;
 export declare let getReleases: (repo: string) => Promise<any>;

package/dist/commands/toolchain/toolchain-utils.js

@@ -1,4 +1,6 @@
 import path from 'node:path';
+import { unzipSync } from 'node:zlib';
+import { chmodSync } from 'node:fs';
 import fs from 'fs-extra';
 import decompress from 'decompress';
 import decompressTarxz from 'decomp-tarxz';
@@ -6,7 +8,7 @@ import { deleteSync } from 'del';
 import { Octokit } from 'octokit';
 import tar from 'tar';
 import { getRootDir } from '../../mops.js';
-export let downloadGithubRelease = async (url, dest) => {
+export let downloadAndExtract = async (url, dest) => {
     let res = await fetch(url);
     if (res.status !== 200) {
         console.error(`ERROR ${res.status} ${url}`);
@@ -27,12 +29,17 @@ export let downloadGithubRelease = async (url, dest) => {
             deleteSync([tmpDir]);
         });
     }
-    else {
+    else if (archive.endsWith('tar.gz')) {
         await tar.extract({
             file: archive,
             cwd: dest,
         });
     }
+    else if (archive.endsWith('.gz')) {
+        let destFile = path.join(dest, path.parse(archive).name);
+        fs.writeFileSync(destFile, unzipSync(buffer));
+        chmodSync(destFile, 0o700);
+    }
     deleteSync([tmpDir], { force: true });
 };
 export let getLatestReleaseTag = async (repo) => {

package/dist/commands/toolchain/wasmtime.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import { globalCacheDir } from '../../mops.js';
-import { downloadGithubRelease } from './toolchain-utils.js';
+import { downloadAndExtract } from './toolchain-utils.js';
 let cacheDir = path.join(globalCacheDir, 'wasmtime');
 export let isCached = (version) => {
     let dir = path.join(cacheDir, version);
@@ -19,5 +19,5 @@ export let download = async (version, { silent = false } = {}) => {
     let arch = process.arch.startsWith('arm') ? 'aarch64' : 'x86_64';
     let url = `https://github.com/bytecodealliance/wasmtime/releases/download/v${version}/wasmtime-v${version}-${arch}-${platfrom}.tar.xz`;
     silent || console.log(`Downloading ${url}`);
-    await downloadGithubRelease(url, path.join(cacheDir, version));
+    await downloadAndExtract(url, path.join(cacheDir, version));
 };

package/dist/mops.js

@@ -93,7 +93,7 @@ export let getIdentity = async () => {
 };
 export function getClosestConfigFile(dir = process.cwd()) {
     if (!path.basename(dir)) {
-        throw '';
+        return '';
     }
     let configFile = path.join(dir, 'mops.toml');
     if (fs.existsSync(configFile)) {

package/dist/package.json

@@ -1,9 +1,10 @@
 {
   "name": "ic-mops",
-  "version": "0.36.1",
+  "version": "0.37.0-pre.0",
   "type": "module",
   "bin": {
-    "mops": "dist/cli.js"
+    "mops": "dist/bin/mops.js",
+    "moc-wrapper": "bin/moc-wrapper.sh"
   },
   "files": [
     "*",
@@ -45,13 +46,15 @@
     "camelcase": "^7.0.1",
     "chalk": "^5.3.0",
     "chokidar": "^3.5.3",
-    "commander": "^11.0.0",
+    "commander": "11.1.0",
     "debounce": "^1.2.1",
+    "decomp-tarxz": "0.1.1",
     "decompress": "^4.2.1",
     "del": "^7.0.0",
     "dhall-to-json-cli": "^1.7.6",
     "eslint": "^8.45.0",
     "execa": "7.1.1",
+    "fs-extra": "11.2.0",
     "get-folder-size": "^4.0.0",
     "glob": "^10.3.3",
     "globby": "^13.2.2",
@@ -63,6 +66,7 @@
     "minimatch": "^9.0.3",
     "ncp": "^2.0.0",
     "node-fetch": "^3.3.2",
+    "octokit": "3.1.2",
     "pem-file": "^1.0.1",
     "prompts": "^2.4.2",
     "stream-to-promise": "^3.0.0",
@@ -73,6 +77,7 @@
     "@tsconfig/strictest": "^2.0.1",
     "@types/debounce": "^1.2.1",
     "@types/decompress": "^4.2.4",
+    "@types/fs-extra": "11.0.4",
     "@types/glob": "^8.1.0",
     "@types/ncp": "^2.0.5",
     "@types/node": "^20.4.4",

package/dist/types.d.ts

@@ -17,6 +17,7 @@ export type Config = {
     };
     dependencies?: Dependencies;
     'dev-dependencies'?: Dependencies;
+    toolchain?: Toolchain;
 };
 export type Dependencies = Record<string, Dependency>;
 export type Dependency = {
@@ -25,3 +26,9 @@ export type Dependency = {
     repo?: string;
     path?: string;
 };
+export type Toolchain = {
+    moc?: string;
+    wasmtime?: string;
+    'pocket-ic'?: string;
+};
+export type Tool = 'moc' | 'wasmtime' | 'pocket-ic';

package/global.d.ts

@@ -1,2 +1,3 @@
 declare module 'pem-file';
-declare module 'get-folder-size';
+declare module 'get-folder-size';
+declare module 'decomp-tarxz';

package/moc-wrapper.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env tsx
+
+import {ExecException, execSync} from 'child_process';
+
+try {
+	execSync('/home/zen/.cache/mocv/versions/current/moc ' + process.argv.slice(2).join(' '), {cwd: process.cwd(), stdio: 'inherit'});
+}
+catch (err: unknown) {
+	process.exit((err as ExecException).code || 1);
+}

package/mops.ts

@@ -106,9 +106,9 @@ export let getIdentity = async (): Promise<Identity | undefined> => {
 	return undefined;
 };
 
-export function getClosestConfigFile(dir = process.cwd()) {
+export function getClosestConfigFile(dir = process.cwd()) : string {
 	if (!path.basename(dir)) {
-		throw '';
+		return '';
 	}
 	let configFile = path.join(dir, 'mops.toml');
 	if (fs.existsSync(configFile)) {

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "ic-mops",
-  "version": "0.36.1",
+  "version": "0.37.0-pre.0",
   "type": "module",
   "bin": {
-    "mops": "dist/cli.js"
+    "mops": "dist/bin/mops.js",
+    "moc-wrapper": "bin/moc-wrapper.sh"
   },
   "files": [
     "*",
@@ -45,13 +46,15 @@
     "camelcase": "^7.0.1",
     "chalk": "^5.3.0",
     "chokidar": "^3.5.3",
-    "commander": "^11.0.0",
+    "commander": "11.1.0",
     "debounce": "^1.2.1",
+    "decomp-tarxz": "0.1.1",
     "decompress": "^4.2.1",
     "del": "^7.0.0",
     "dhall-to-json-cli": "^1.7.6",
     "eslint": "^8.45.0",
     "execa": "7.1.1",
+    "fs-extra": "11.2.0",
     "get-folder-size": "^4.0.0",
     "glob": "^10.3.3",
     "globby": "^13.2.2",
@@ -63,6 +66,7 @@
     "minimatch": "^9.0.3",
     "ncp": "^2.0.0",
     "node-fetch": "^3.3.2",
+    "octokit": "3.1.2",
     "pem-file": "^1.0.1",
     "prompts": "^2.4.2",
     "stream-to-promise": "^3.0.0",
@@ -73,6 +77,7 @@
     "@tsconfig/strictest": "^2.0.1",
     "@types/debounce": "^1.2.1",
     "@types/decompress": "^4.2.4",
+    "@types/fs-extra": "11.0.4",
     "@types/glob": "^8.1.0",
     "@types/ncp": "^2.0.5",
     "@types/node": "^20.4.4",

package/types.ts

@@ -17,6 +17,7 @@ export type Config = {
 	};
 	dependencies?: Dependencies;
 	'dev-dependencies'?: Dependencies;
+	toolchain?: Toolchain;
 };
 
 export type Dependencies = Record<string, Dependency>;
@@ -26,4 +27,12 @@ export type Dependency = {
 	version?: string; // mops package
 	repo?: string; // github package
 	path?: string; // local package
-}
+}
+
+export type Toolchain = {
+	moc?: string;
+	wasmtime?: string;
+	'pocket-ic'?: string;
+};
+
+export type Tool = 'moc' | 'wasmtime' | 'pocket-ic';

package/cli-local.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env bun
-
-import './cli.js';