ic-mops 0.36.1 → 0.37.0

package/commands/toolchain/index.ts

@@ -0,0 +1,325 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import {execSync} from 'node:child_process';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import {createLogUpdate} from 'log-update';
+import {checkConfigFile, getClosestConfigFile, getRootDir, globalCacheDir, readConfig, writeConfig} from '../../mops.js';
+import {Tool} from '../../types.js';
+import * as moc from './moc.js';
+import * as pocketIc from './pocket-ic.js';
+import * as wasmtime from './wasmtime.js';
+
+function getToolUtils(tool: Tool) {
+	if (tool === 'moc') {
+		return moc;
+	}
+	else if (tool === 'pocket-ic') {
+		return pocketIc;
+	}
+	else if (tool === 'wasmtime') {
+		return wasmtime;
+	}
+	else {
+		console.error(`Unknown tool '${tool}'`);
+		process.exit(1);
+	}
+}
+
+async function ensureToolchainInited({strict = true} = {}) {
+	// auto init in CI
+	if (process.env.CI) {
+		await init({silent: true});
+		return true;
+	}
+
+	// for non-stict perform check only if dfx.json exists and moc is listed in [toolchain] section
+	let rootDir = getRootDir();
+	let config = readConfig();
+	if (!strict && (!config.toolchain?.moc || rootDir && !fs.existsSync(path.join(rootDir, 'dfx.json')))) {
+		return true;
+	}
+
+	try {
+		let res = execSync('which moc-wrapper').toString().trim();
+		if (res && process.env.DFX_MOC_PATH === 'moc-wrapper') {
+			return true;
+		}
+	}
+	catch {}
+	console.error('Toolchain management is not initialized. Run "mops toolchain init"');
+	process.exit(1);
+}
+
+// update shell config files to set DFX_MOC_PATH to moc-wrapper
+async function init({reset = false, silent = 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, process.env.GITHUB_ENV || ''].map(x => x).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 shellConfigFile of shellConfigFiles) {
+		let text = fs.readFileSync(shellConfigFile).toString();
+		let setDfxMocPathLine = '\nexport DFX_MOC_PATH=moc-wrapper';
+
+		let newLines = [
+			setDfxMocPathLine,
+		];
+
+		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
+			setDfxMocPathLine,
+		];
+
+		// 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) {
+				if (shellConfigFile === process.env.GITHUB_ENV) {
+					newLine = newLine.replace('export ', '');
+				}
+				text += newLine;
+			}
+			text += '\n';
+		}
+
+		fs.writeFileSync(shellConfigFile, text);
+	}
+
+	if (!silent) {
+		console.log(chalk.green('Success!'));
+		console.log('Restart terminal to apply changes');
+	}
+}
+
+async function download(tool: Tool, version: string, {silent = false, verbose = false} = {}) {
+	let toolUtils = getToolUtils(tool);
+	await toolUtils.download(version, {silent, verbose});
+}
+
+async function installAll({silent = false, verbose = false} = {}) {
+	let config = readConfig();
+
+	if (!config.toolchain) {
+		return;
+	}
+
+	let logUpdate = createLogUpdate(process.stdout, {showCursor: true});
+
+	let log = (...args: string[]) => {
+		if (silent) {
+			return;
+		}
+		if (verbose) {
+			console.log(...args);
+		}
+		else {
+			logUpdate(...args);
+		}
+	};
+
+	log('Installing toolchain...');
+
+	if (config.toolchain?.moc) {
+		log('Installing moc', config.toolchain.moc);
+		await download('moc', config.toolchain.moc, {verbose});
+	}
+	if (config.toolchain?.wasmtime) {
+		log('Installing wasmtime', config.toolchain.wasmtime);
+		await download('wasmtime', config.toolchain.wasmtime, {verbose});
+	}
+	if (config.toolchain?.['pocket-ic']) {
+		log('Installing pocket-ic', config.toolchain['pocket-ic']);
+		await download('pocket-ic', config.toolchain['pocket-ic'], {verbose});
+	}
+
+	if (!silent) {
+		logUpdate.clear();
+		console.log(chalk.green('Toolchain installed'));
+	}
+}
+
+async function promptVersion(tool: Tool): Promise<string> {
+	let config = readConfig();
+	config.toolchain = config.toolchain || {};
+	let current = config.toolchain[tool];
+
+	let toolUtils = getToolUtils(tool);
+	let releases = await toolUtils.getReleases();
+	let versions = releases.map((item: {tag_name: any;}) => item.tag_name);
+	let currentIndex = versions.indexOf(current);
+
+	let res = await prompts({
+		type: 'select',
+		name: 'version',
+		message: `Select ${tool} 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,
+	});
+
+	return res.version;
+}
+
+// download binary and set version in mops.toml
+async function use(tool: Tool, version?: string) {
+	if (tool === 'moc') {
+		await ensureToolchainInited();
+	}
+	if (!version) {
+		version = await promptVersion(tool);
+	}
+	if (!version) {
+		return;
+	}
+	if (version === 'latest') {
+		version = await getToolUtils(tool).getLatestReleaseTag();
+	}
+
+	await download(tool, version);
+
+	let config = readConfig();
+	config.toolchain = config.toolchain || {};
+
+	let oldVersion = config.toolchain[tool];
+
+	config.toolchain[tool] = version;
+	writeConfig(config);
+
+	if (oldVersion === version) {
+		console.log((`${tool} ${version} is already installed`));
+	}
+	else {
+		console.log(chalk.green(`Installed ${tool} ${version}`));
+	}
+}
+
+// download latest binary and set version in mops.toml
+async function update(tool?: Tool) {
+	if (tool === 'moc') {
+		await ensureToolchainInited();
+	}
+
+	let config = readConfig();
+	config.toolchain = config.toolchain || {};
+
+	let tools = tool ? [tool] : Object.keys(config.toolchain) as Tool[];
+
+	for (let tool of tools) {
+		if (!config.toolchain[tool]) {
+			console.error(`Tool '${tool}' is not defined in [toolchain] section in mops.toml`);
+			process.exit(1);
+		}
+
+		let toolUtils = getToolUtils(tool);
+		let version = await toolUtils.getLatestReleaseTag();
+
+		await download(tool, version);
+
+		let oldVersion = config.toolchain[tool];
+		config.toolchain[tool] = version;
+		writeConfig(config);
+
+		if (oldVersion === version) {
+			console.log((`Latest ${tool} ${version} is already installed`));
+		}
+		else {
+			console.log(chalk.green(`Installed ${tool} ${version}`));
+		}
+	}
+}
+
+// return current version from mops.toml
+async function bin(tool: Tool, {fallback = false} = {}): Promise<string> {
+	let hasConfig = getClosestConfigFile();
+
+	// fallback to dfx moc
+	if (!hasConfig) {
+		if (tool === 'moc' && fallback) {
+			return execSync('dfx cache show').toString().trim() + '/moc';
+		}
+		checkConfigFile();
+		process.exit(1);
+	}
+
+	let config = readConfig();
+	let version = config.toolchain?.[tool];
+
+	if (version) {
+		if (tool === 'moc') {
+			await ensureToolchainInited();
+		}
+
+		await download(tool, version, {silent: true});
+
+		if (tool === 'moc') {
+			return path.join(globalCacheDir, 'moc', version, tool);
+		}
+		else {
+			return path.join(globalCacheDir, tool, version, tool);
+		}
+	}
+	else {
+		// fallback to dfx moc
+		if (tool === 'moc' && fallback) {
+			return execSync('dfx cache show').toString().trim() + '/moc';
+		}
+		console.error(`Tool '${tool}' is not defined in [toolchain] section in mops.toml`);
+		console.log(`Run ${chalk.green(`mops toolchain use ${tool}`)} to install it`);
+		process.exit(1);
+	}
+}
+
+export let toolchain = {
+	init,
+	use,
+	update,
+	bin,
+	installAll,
+	ensureToolchainInited,
+};

package/commands/toolchain/moc.ts

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+
+import {globalCacheDir} from '../../mops.js';
+import * as toolchainUtils from './toolchain-utils.js';
+
+let cacheDir = path.join(globalCacheDir, 'moc');
+
+export let repo = 'dfinity/motoko';
+
+export let getLatestReleaseTag = async () => {
+	return toolchainUtils.getLatestReleaseTag(repo);
+};
+
+export let getReleases = async () => {
+	return toolchainUtils.getReleases(repo);
+};
+
+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, verbose = 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)) {
+		if (verbose) {
+			console.log(`moc ${version} is already installed`);
+		}
+		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`;
+	}
+
+	if (verbose && !silent) {
+		console.log(`Downloading ${url}`);
+	}
+
+	await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
+};

package/commands/toolchain/pocket-ic.ts

@@ -0,0 +1,74 @@
+import path from 'node:path';
+import fs from 'node:fs';
+
+import {globalCacheDir} from '../../mops.js';
+import * as toolchainUtils from './toolchain-utils.js';
+
+let cacheDir = path.join(globalCacheDir, 'pocket-ic');
+
+export let repo = 'dfinity/pocketic';
+
+export let getLatestReleaseTag = async () => {
+	return '1.0.0';
+	// return toolchainUtils.getLatestReleaseTag(repo);
+};
+
+export let getReleases = async () => {
+	// return toolchainUtils.getReleases(repo);
+	return [
+		// {
+		// 	tag_name: '2.0.1',
+		// 	published_at: new Date('2023-11-23'),
+		// 	draft: false,
+		// },
+		// {
+		// 	tag_name: '2.0.0',
+		// 	published_at: new Date('2023-11-21'),
+		// 	draft: false,
+		// },
+		{
+			tag_name: '1.0.0',
+			published_at: new Date('2023-10-12'),
+			draft: false,
+		},
+	];
+};
+
+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, verbose = false} = {}) => {
+	if (!version) {
+		console.error('version is not defined');
+		process.exit(1);
+	}
+	if (version !== '1.0.0') {
+		console.error('Currently only pocket-ic 1.0.0 is supported');
+		process.exit(1);
+	}
+	if (isCached(version)) {
+		if (verbose) {
+			console.log(`pocket-ic ${version} is already installed`);
+		}
+		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`;
+
+	if (verbose && !silent) {
+		console.log(`Downloading ${url}`);
+	}
+
+	await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
+};

package/commands/toolchain/toolchain-utils.ts

@@ -0,0 +1,83 @@
+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, tmpDir, {
+			plugins: [decompressTarxz()],
+		}).catch(() => {
+			deleteSync([tmpDir]);
+		});
+		fs.cpSync(path.join(tmpDir, path.parse(archive).name.replace('.tar', '')), dest, {recursive: true});
+	}
+	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> => {
+	let releases = await getReleases(repo);
+	let release = releases.find((release: any) => !release.prerelease && !release.draft);
+	if (!release?.tag_name) {
+		console.error(`Failed to fetch latest release tag for ${repo}`);
+		process.exit(1);
+	}
+	return release.tag_name.replace(/^v/, '');
+};
+
+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.map((release: any) => {
+		return {
+			...release,
+			tag_name: release.tag_name.replace(/^v/, ''),
+		};
+	});
+};

package/commands/toolchain/wasmtime.ts

@@ -0,0 +1,45 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+
+import {globalCacheDir} from '../../mops.js';
+import * as toolchainUtils from './toolchain-utils.js';
+
+let cacheDir = path.join(globalCacheDir, 'wasmtime');
+
+export let repo = 'bytecodealliance/wasmtime';
+
+export let getLatestReleaseTag = async () => {
+	return toolchainUtils.getLatestReleaseTag(repo);
+};
+
+export let getReleases = async () => {
+	return toolchainUtils.getReleases(repo);
+};
+
+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, verbose = false} = {}) => {
+	if (!version) {
+		console.error('version is not defined');
+		process.exit(1);
+	}
+	if (isCached(version)) {
+		if (verbose) {
+			console.log(`wasmtime ${version} is already installed`);
+		}
+		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`;
+
+	if (verbose && !silent) {
+		console.log(`Downloading ${url}`);
+	}
+
+	await toolchainUtils.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/cache.js

@@ -32,7 +32,7 @@ export let copyCache = (pkgId, dest) => {
     });
 };
 export let cacheSize = async () => {
-    let dir = path.join(globalCacheDir, 'packages');
+    let dir = path.join(globalCacheDir);
     fs.mkdirSync(dir, { recursive: true });
     let size = await getFolderSize.strict(dir);
     if (size < 1024 * 1024) {
@@ -41,6 +41,6 @@ export let cacheSize = async () => {
     return (size / 1024 / 1024).toFixed(2) + ' MB';
 };
 export let cleanCache = async () => {
-    let dir = path.join(globalCacheDir, 'packages');
+    let dir = path.join(globalCacheDir);
     fs.rmSync(dir, { recursive: true, force: true });
 };

package/dist/cli.d.ts

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