ic-mops 0.37.0-pre.0 → 0.37.1

package/commands/toolchain/index.ts

@@ -2,14 +2,58 @@ 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';
+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} = {}) {
+async function init({reset = false, silent = false} = {}) {
 	if (process.platform == 'win32') {
 		console.error('Windows is not supported. Please use WSL');
 		process.exit(1);
@@ -30,7 +74,7 @@ async function init({reset = false} = {}) {
 	let zshrc = path.join(os.homedir(), '.zshrc');
 	let bashrc = path.join(os.homedir(), '.bashrc');
 
-	let shellConfigFiles = [bashrc, zshrc].filter((file) => {
+	let shellConfigFiles = [bashrc, zshrc, process.env.GITHUB_ENV || ''].map(x => x).filter((file) => {
 		return fs.existsSync(file);
 	});
 
@@ -40,12 +84,12 @@ async function init({reset = false} = {}) {
 	}
 
 	// 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"';
+	for (let shellConfigFile of shellConfigFiles) {
+		let text = fs.readFileSync(shellConfigFile).toString();
+		let setDfxMocPathLine = '\nexport DFX_MOC_PATH=moc-wrapper';
 
 		let newLines = [
-			setDfxLine,
+			setDfxMocPathLine,
 		];
 
 		let oldLines = [
@@ -53,7 +97,7 @@ async function init({reset = false} = {}) {
 			`\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,
+			setDfxMocPathLine,
 		];
 
 		// remove old lines
@@ -71,83 +115,211 @@ async function init({reset = false} = {}) {
 				text += '\n';
 			}
 			for (let newLine of newLines) {
+				if (shellConfigFile === process.env.GITHUB_ENV) {
+					newLine = newLine.replace('export ', '');
+				}
 				text += newLine;
 			}
 			text += '\n';
 		}
 
-		fs.writeFileSync(configFile, text);
+		fs.writeFileSync(shellConfigFile, text);
 	}
 
-	console.log(chalk.green('Success!'));
+	if (!silent) {
+		console.log(chalk.green('Success!'));
+		console.log('Restart terminal to apply changes');
+	}
 }
 
-async function download(tool: Tool, version: string) {
-	if (tool === 'moc') {
-		await moc.download(version);
+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 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']);
-// 	}
-// }
+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) {
+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) {
+async function bin(tool: Tool, {fallback = false} = {}): Promise<string> {
 	let hasConfig = getClosestConfigFile();
 
 	// fallback to dfx moc
 	if (!hasConfig) {
-		console.log(execSync('dfx cache show').toString().trim() + '/moc');
-		return;
+		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) {
-		// fallback to dfx moc
+	if (version) {
 		if (tool === 'moc') {
-			console.log(execSync('dfx cache show').toString().trim() + '/moc');
-			return;
+			await ensureToolchainInited();
 		}
-		console.error(`Toolchain '${tool}' is not defined in mops.toml`);
-		process.exit(1);
-	}
 
-	if (version) {
-		await download(tool, version);
+		await download(tool, version, {silent: true});
 
 		if (tool === 'moc') {
-			console.log(path.join(globalCacheDir, 'moc', version, 'moc'));
+			return path.join(globalCacheDir, 'moc', version, tool);
 		}
 		else {
-			console.log(path.join(globalCacheDir, tool, version, 'moc'));
+			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

@@ -2,16 +2,26 @@ import path from 'node:path';
 import fs from 'fs-extra';
 
 import {globalCacheDir} from '../../mops.js';
-import {downloadAndExtract} from './toolchain-utils.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} = {}) => {
+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);
@@ -21,6 +31,9 @@ export let download = async (version: string, {silent = false} = {}) => {
 		process.exit(1);
 	}
 	if (isCached(version)) {
+		if (verbose) {
+			console.log(`moc ${version} is already installed`);
+		}
 		return;
 	}
 
@@ -37,7 +50,9 @@ export let download = async (version: string, {silent = false} = {}) => {
 		url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
 	}
 
-	silent || console.log(`Downloading ${url}`);
+	if (verbose && !silent) {
+		console.log(`Downloading ${url}`);
+	}
 
-	await downloadAndExtract(url, path.join(cacheDir, version));
+	await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
 };

package/commands/toolchain/pocket-ic.ts

@@ -2,21 +2,56 @@ import path from 'node:path';
 import fs from 'node:fs';
 
 import {globalCacheDir} from '../../mops.js';
-import {downloadAndExtract} from './toolchain-utils.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} = {}) => {
+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;
 	}
 
@@ -24,14 +59,16 @@ export let download = async (version: string, {silent = false} = {}) => {
 	let arch = 'x86_64';
 
 	let hashes: Record<string, string> = {
-		'2.0.1': '69e1408347723dbaa7a6cd2faa9b65c42abbe861',
-		'2.0.0': '29ec86dc9f9ca4691d4d4386c8b2aa41e14d9d16',
+		// '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}`);
+	if (verbose && !silent) {
+		console.log(`Downloading ${url}`);
+	}
 
-	await downloadAndExtract(url, path.join(cacheDir, version));
+	await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
 };

package/commands/toolchain/toolchain-utils.ts

@@ -30,12 +30,12 @@ export let downloadAndExtract = async (url: string, dest: string) => {
 	fs.mkdirSync(dest, {recursive: true});
 
 	if (archive.endsWith('.xz')) {
-		await decompress(archive, dest, {
-			strip: 1,
+		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({
@@ -52,10 +52,14 @@ export let downloadAndExtract = async (url: string, dest: string) => {
 	deleteSync([tmpDir], {force: true});
 };
 
-export let getLatestReleaseTag = async (repo: string): Promise<string | undefined> => {
+export let getLatestReleaseTag = async (repo: string): Promise<string> => {
 	let releases = await getReleases(repo);
 	let release = releases.find((release: any) => !release.prerelease && !release.draft);
-	return release?.tag_name;
+	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) => {
@@ -70,5 +74,10 @@ export let getReleases = async (repo: string) => {
 		console.log('Releases fetch error');
 		process.exit(1);
 	}
-	return res.data;
+	return res.data.map((release: any) => {
+		return {
+			...release,
+			tag_name: release.tag_name.replace(/^v/, ''),
+		};
+	});
 };

package/commands/toolchain/wasmtime.ts

@@ -2,21 +2,34 @@ import path from 'node:path';
 import fs from 'fs-extra';
 
 import {globalCacheDir} from '../../mops.js';
-import {downloadAndExtract} from './toolchain-utils.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} = {}) => {
+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;
 	}
 
@@ -24,7 +37,9 @@ export let download = async (version: string, {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}`);
+	if (verbose && !silent) {
+		console.log(`Downloading ${url}`);
+	}
 
-	await downloadAndExtract(url, path.join(cacheDir, version));
+	await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
 };

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.js

@@ -84,6 +84,7 @@ program
     if (!compatible) {
         return;
     }
+    await toolchain.ensureToolchainInited({ strict: false });
     if (pkg) {
         // @deprecated
         console.log(chalk.yellow('Consider using the \'mops add\' command to install a specific package.'));
@@ -91,6 +92,7 @@ program
     }
     else {
         await installAll(options);
+        await toolchain.installAll(options);
     }
 });
 // publish
@@ -144,6 +146,7 @@ program
         process.exit(1);
     }
     await installAll({ silent: true, lock: 'ignore' });
+    await toolchain.ensureToolchainInited({ strict: false });
     let sourcesArr = await sources(options);
     console.log(sourcesArr.join('\n'));
 });
@@ -297,28 +300,43 @@ toolchainCommand
     .command('init')
     .description('One-time initialization of toolchain management')
     .action(async () => {
-    toolchain.init();
+    await toolchain.init();
 });
 toolchainCommand
     .command('reset')
     .description('Uninstall toolchain management')
     .action(async () => {
-    toolchain.init({ reset: true });
+    await 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>'))
+    .addArgument(new Argument('[version]'))
     .action(async (tool, version) => {
-    toolchain.use(tool, version);
+    if (!checkConfigFile()) {
+        process.exit(1);
+    }
+    await toolchain.use(tool, version);
+});
+toolchainCommand
+    .command('update')
+    .description('Update specified tool or all tools to the latest version and update mops.toml')
+    .addArgument(new Argument('[tool]').choices(['moc', 'wasmtime', 'pocket-ic']))
+    .action(async (tool) => {
+    if (!checkConfigFile()) {
+        process.exit(1);
+    }
+    await toolchain.update(tool);
 });
 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);
+    .addOption(new Option('--fallback', 'Fallback to the moc that comes with dfx if moc is not specified in the [toolchain] section'))
+    .action(async (tool, options) => {
+    let bin = await toolchain.bin(tool, options);
+    console.log(bin);
 });
 program.addCommand(toolchainCommand);
 program.parse();

package/dist/commands/add.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import chalk from 'chalk';
-import logUpdate from 'log-update';
+import { createLogUpdate } from 'log-update';
 import { checkConfigFile, getGithubCommit, parseGithubURL, readConfig, writeConfig } from '../mops.js';
 import { getHighestVersion } from '../api/getHighestVersion.js';
 import { installFromGithub } from '../vessel.js';
@@ -91,6 +91,7 @@ export async function add(name, { verbose = false, dev = false, lock } = {}, asN
         throw Error(`Invalid config file: [${depsProp}] not found`);
     }
     writeConfig(config);
+    let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
     if (lock !== 'ignore') {
         logUpdate('Checking integrity...');
     }

package/dist/commands/bench-replica.d.ts

@@ -1,4 +1,4 @@
-import { PocketIc } from '@hadronous/pic';
+import { PocketIc } from 'pic-ic';
 export declare class BenchReplica {
     type: 'dfx' | 'pocket-ic';
     verbose: boolean;