ic-mops 0.36.1 → 0.37.0

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) => {
@@ -83,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.'));
@@ -90,6 +92,7 @@ program
     }
     else {
         await installAll(options);
+        await toolchain.installAll(options);
     }
 });
 // publish
@@ -143,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'));
 });
@@ -290,4 +294,49 @@ 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 () => {
+    await toolchain.init();
+});
+toolchainCommand
+    .command('reset')
+    .description('Uninstall toolchain management')
+    .action(async () => {
+    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]'))
+    .action(async (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']))
+    .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;

package/dist/commands/bench-replica.js

@@ -2,9 +2,10 @@ import { execSync } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
 import { execaCommand } from 'execa';
-import { PocketIc } from '@hadronous/pic';
+import { PocketIc } from 'pic-ic';
 import { getRootDir } from '../mops.js';
 import { createActor, idlFactory } from '../declarations/bench/index.js';
+import { toolchain } from './toolchain/index.js';
 export class BenchReplica {
     constructor(type, verbose = false) {
         this.verbose = false;
@@ -21,7 +22,8 @@ export class BenchReplica {
             execSync('dfx start --background --clean --artificial-delay 0' + (this.verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['inherit', this.verbose ? 'inherit' : 'ignore', 'inherit'] });
         }
         else {
-            this.pocketIc = await PocketIc.create();
+            let pocketIcBin = await toolchain.bin('pocket-ic');
+            this.pocketIc = await PocketIc.create(pocketIcBin);
         }
     }
     async stop() {
@@ -30,7 +32,7 @@ export class BenchReplica {
             execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe'] });
         }
         else if (this.pocketIc) {
-            this.pocketIc.tearDown();
+            await this.pocketIc.tearDown();
         }
     }
     async deploy(name, wasm, cwd = process.cwd()) {

package/dist/commands/docs.js

@@ -1,4 +1,4 @@
-import { spawn, execSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
@@ -7,22 +7,25 @@ import { deleteSync } from 'del';
 import tar from 'tar';
 import streamToPromise from 'stream-to-promise';
 import { getRootDir } from '../mops.js';
-let moDoc;
+import { toolchain } from './toolchain/index.js';
+let moDocPath;
 export async function docs({ silent = false } = {}) {
     let rootDir = getRootDir();
     let docsDir = path.join(rootDir, '.mops/.docs');
     let docsDirRelative = path.relative(process.cwd(), docsDir);
     deleteSync([docsDir], { force: true });
-    // detect mocv
+    // detect mocv (legacy)
     if (process.env.DFX_MOC_PATH && process.env.DFX_MOC_PATH.includes('mocv/versions')) {
-        moDoc = process.env.DFX_MOC_PATH.replace(/\/moc$/, '/mo-doc');
+        moDocPath = process.env.DFX_MOC_PATH.replace(/\/moc$/, '/mo-doc');
     }
     else {
-        moDoc = execSync('dfx cache show').toString().trim() + '/mo-doc';
+        // fallbacks to dfx moc if not specified in config
+        let mocPath = await toolchain.bin('moc');
+        moDocPath = mocPath.replace(/\/moc$/, '/mo-doc');
     }
     // generate docs
     await new Promise((resolve) => {
-        let proc = spawn(moDoc, [`--source=${path.join(rootDir, 'src')}`, `--output=${docsDirRelative}`, '--format=adoc']);
+        let proc = spawn(moDocPath, [`--source=${path.join(rootDir, 'src')}`, `--output=${docsDirRelative}`, '--format=adoc']);
         // stdout
         proc.stdout.on('data', (data) => {
             let text = data.toString().trim();

package/dist/commands/install-all.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import logUpdate from 'log-update';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { createLogUpdate } from 'log-update';
 import { checkConfigFile, readConfig } from '../mops.js';
 import { install } from './install.js';
 import { installFromGithub } from '../vessel.js';
@@ -26,6 +27,8 @@ export async function installAll({ verbose = false, silent = false, lock } = {})
             installedPackages = { ...installedPackages, ...res };
         }
     }
+    let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
+    // let logUpdate = l;
     if (!silent && lock !== 'ignore') {
         logUpdate('Checking integrity...');
     }
@@ -35,6 +38,6 @@ export async function installAll({ verbose = false, silent = false, lock } = {})
     ]);
     if (!silent) {
         logUpdate.clear();
-        console.log(chalk.green('All packages installed'));
+        console.log(chalk.green('Packages installed'));
     }
 }

package/dist/commands/install.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import fs from 'node:fs';
-import logUpdate from 'log-update';
+import { createLogUpdate } from 'log-update';
 import chalk from 'chalk';
 import { checkConfigFile, formatDir, progressBar, readConfig } from '../mops.js';
 import { getHighestVersion } from '../api/getHighestVersion.js';
@@ -13,6 +13,7 @@ export async function install(pkg, version = '', { verbose = false, silent = fal
     if (!checkConfigFile()) {
         return false;
     }
+    let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
     // progress
     let total = Infinity;
     let step = 0;
@@ -75,6 +76,9 @@ export async function install(pkg, version = '', { verbose = false, silent = fal
     if (verbose) {
         silent || logUpdate.done();
     }
+    else {
+        logUpdate.clear();
+    }
     // install dependencies
     let ok = true;
     let config = readConfig(path.join(dir, 'mops.toml'));

package/dist/commands/publish.js

@@ -289,6 +289,7 @@ export async function publish(options = {}) {
     fs.rmSync(path.join(rootDir, '.mops/.docs'), { force: true, recursive: true });
     // finish
     progress();
+    logUpdate.done();
     let res = await actor.finishPublish(puiblishingId);
     if ('err' in res) {
         console.log(chalk.red('Error: ') + res.err);

package/dist/commands/test/test.js

@@ -1,4 +1,4 @@
-import { spawn, execSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -7,7 +7,7 @@ import { globSync } from 'glob';
 import chokidar from 'chokidar';
 import debounce from 'debounce';
 import { sources } from '../sources.js';
-import { getRootDir } from '../../mops.js';
+import { getRootDir, readConfig } from '../../mops.js';
 import { parallel } from '../../parallel.js';
 import { MMF1 } from './mmf1.js';
 import { absToRel } from './utils.js';
@@ -15,6 +15,7 @@ import { VerboseReporter } from './reporters/verbose-reporter.js';
 import { FilesReporter } from './reporters/files-reporter.js';
 import { CompactReporter } from './reporters/compact-reporter.js';
 import { SilentReporter } from './reporters/silent-reporter.js';
+import { toolchain } from '../toolchain/index.js';
 let ignore = [
     '**/node_modules/**',
     '**/.mops/**',
@@ -57,7 +58,8 @@ export async function test(filter = '', { watch = false, reporter = 'verbose', m
         }
     }
 }
-let mocPath = process.env.DFX_MOC_PATH;
+let mocPath = '';
+let wasmtimePath = '';
 export async function runAll(reporterName = 'verbose', filter = '', mode = 'interpreter') {
     let reporter;
     if (reporterName == 'compact') {
@@ -99,19 +101,29 @@ export async function testWithReporter(reporter, filter = '', mode = 'interprete
         return false;
     }
     reporter.addFiles(files);
+    let config = readConfig();
     let sourcesArr = await sources();
     if (!mocPath) {
-        mocPath = execSync('dfx cache show').toString().trim() + '/moc';
+        mocPath = await toolchain.bin('moc');
     }
     let wasmDir = `${getRootDir()}/.mops/.test/`;
     fs.mkdirSync(wasmDir, { recursive: true });
     await parallel(os.cpus().length, files, async (file) => {
         let mmf = new MMF1('store', absToRel(file));
         let wasiMode = mode === 'wasi' || fs.readFileSync(file, 'utf8').startsWith('// @testmode wasi');
-        let promise = new Promise((resolve) => {
-            if (!mocPath) {
-                mocPath = 'moc';
+        if (wasiMode && !wasmtimePath) {
+            // ensure wasmtime is installed or specified in config
+            if (config.toolchain?.wasmtime) {
+                wasmtimePath = await toolchain.bin('wasmtime');
+            }
+            // fallback wasmtime to global binary if not specified in config (legacy)
+            else {
+                wasmtimePath = 'wasmtime';
+                console.log(chalk.yellow('Warning:'), 'Wasmtime is not specified in config. Using global binary "wasmtime". This will be removed in the future.');
+                console.log(`Run ${chalk.green('mops toolchain use wasmtime')} or add ${chalk.green('wasmtime = "<version>"')} in mops.toml to avoid breaking changes with future versions of mops.`);
             }
+        }
+        let promise = new Promise((resolve) => {
             let mocArgs = ['--hide-warnings', '--error-detail=2', ...sourcesArr.join(' ').split(' '), file].filter(x => x);
             // build and run wasm
             if (wasiMode) {
@@ -123,18 +135,28 @@ export async function testWithReporter(reporter, filter = '', mode = 'interprete
                         return;
                     }
                     // run
-                    let proc = spawn('wasmtime', [
-                        '--max-wasm-stack=2000000',
-                        '--enable-cranelift-nan-canonicalization',
-                        '--wasm-features',
-                        'multi-memory,bulk-memory',
-                        wasmFile,
-                    ], {
-                        env: {
-                            ...process.env,
-                            WASMTIME_NEW_CLI: '0',
-                        }
-                    });
+                    let wasmtimeArgs = [];
+                    if (config.toolchain?.wasmtime && config.toolchain?.wasmtime >= '14.0.0') {
+                        wasmtimeArgs = [
+                            '-S', 'preview2=n',
+                            '-C', 'cache=n',
+                            '-W', 'bulk-memory',
+                            '-W', 'multi-memory',
+                            '-W', 'max-wasm-stack=2000000',
+                            '-W', 'nan-canonicalization=y',
+                            wasmFile,
+                        ];
+                    }
+                    else {
+                        wasmtimeArgs = [
+                            '--max-wasm-stack=2000000',
+                            '--enable-cranelift-nan-canonicalization',
+                            '--wasm-features',
+                            'multi-memory,bulk-memory',
+                            wasmFile,
+                        ];
+                    }
+                    let proc = spawn(wasmtimePath, wasmtimeArgs);
                     await pipeMMF(proc, mmf);
                 }).finally(() => {
                     fs.rmSync(wasmFile, { force: true });

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

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

package/dist/commands/toolchain/index.js

@@ -0,0 +1,274 @@
+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 * as moc from './moc.js';
+import * as pocketIc from './pocket-ic.js';
+import * as wasmtime from './wasmtime.js';
+function getToolUtils(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, version, { 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) => {
+        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) {
+    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) => item.tag_name);
+    let currentIndex = versions.indexOf(current);
+    let res = await prompts({
+        type: 'select',
+        name: 'version',
+        message: `Select ${tool} version`,
+        choices: releases.map((release, i) => {
+            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, version) {
+    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) {
+    if (tool === 'moc') {
+        await ensureToolchainInited();
+    }
+    let config = readConfig();
+    config.toolchain = config.toolchain || {};
+    let tools = tool ? [tool] : Object.keys(config.toolchain);
+    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, { fallback = false } = {}) {
+    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/dist/commands/toolchain/moc.d.ts

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