ic-mops 0.36.0 → 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));
+};