ic-mops 0.37.0-pre.0 → 0.37.0

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

@@ -1,12 +1,26 @@
 import { Tool } from '../../types.js';
-declare function init({ reset }?: {
+declare function ensureToolchainInited({ strict }?: {
+    strict?: boolean | undefined;
+}): Promise<boolean>;
+declare function init({ reset, silent }?: {
     reset?: boolean | undefined;
+    silent?: boolean | undefined;
 }): Promise<void>;
-declare function use(tool: Tool, version: string): Promise<void>;
-declare function bin(tool: Tool): 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

@@ -2,11 +2,52 @@ 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';
+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 } = {}) {
+async function init({ reset = false, silent = false } = {}) {
     if (process.platform == 'win32') {
         console.error('Windows is not supported. Please use WSL');
         process.exit(1);
@@ -24,7 +65,7 @@ async function init({ reset = false } = {}) {
     catch { }
     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);
     });
     if (shellConfigFiles.length === 0) {
@@ -32,18 +73,18 @@ async function init({ reset = false } = {}) {
         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"';
+    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 = [
             // 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,
+            setDfxMocPathLine,
         ];
         // remove old lines
         for (let oldLine of oldLines) {
@@ -58,70 +99,176 @@ 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);
+    }
+    if (!silent) {
+        console.log(chalk.green('Success!'));
+        console.log('Restart terminal to apply changes');
     }
-    console.log(chalk.green('Success!'));
 }
-async function download(tool, version) {
-    if (tool === 'moc') {
-        await moc.download(version);
+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 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) {
+    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) {
+async function bin(tool, { fallback = false } = {}) {
     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/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>;

package/dist/commands/toolchain/moc.js

@@ -1,13 +1,20 @@
 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) => {
     let dir = path.join(cacheDir, version);
     return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'moc'));
 };
-export let download = async (version, { silent = false } = {}) => {
+export let download = async (version, { silent = false, verbose = false } = {}) => {
     if (process.platform == 'win32') {
         console.error('Windows is not supported. Please use WSL');
         process.exit(1);
@@ -17,6 +24,9 @@ export let download = async (version, { silent = false } = {}) => {
         process.exit(1);
     }
     if (isCached(version)) {
+        if (verbose) {
+            console.log(`moc ${version} is already installed`);
+        }
         return;
     }
     let url;
@@ -31,6 +41,8 @@ export let download = async (version, { silent = false } = {}) => {
         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));
+    if (verbose && !silent) {
+        console.log(`Downloading ${url}`);
+    }
+    await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
 };

package/dist/commands/toolchain/mocv.js

@@ -228,7 +228,6 @@ let updateShellConfig = async ({ reset = false, yes = false } = {}) => {
         }
         fs.writeFileSync(configFile, data);
     }
-    ;
     console.log('Success!');
     // console.log(`Run "source ${configFile}" to apply changes`);
     console.log('Restart terminal to apply changes');

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

@@ -1,4 +1,12 @@
+export declare let repo: string;
+export declare let getLatestReleaseTag: () => Promise<string>;
+export declare let getReleases: () => Promise<{
+    tag_name: string;
+    published_at: Date;
+    draft: boolean;
+}[]>;
 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>;