ic-mops 1.11.1 → 2.0.0

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

@@ -1,4 +1,4 @@
-import { Tool } from '../../types.js';
+import { Tool } from "../../types.js";
 declare function ensureToolchainInited({ strict }?: {
     strict?: boolean | undefined;
 }): Promise<boolean>;

package/dist/commands/toolchain/index.js

@@ -1,24 +1,24 @@
-import process from 'node:process';
-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 { checkRequirements } from '../../check-requirements.js';
-import * as moc from './moc.js';
-import * as pocketIc from './pocket-ic.js';
-import * as wasmtime from './wasmtime.js';
+import process from "node:process";
+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 { checkRequirements } from "../../check-requirements.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') {
+    if (tool === "moc") {
         return moc;
     }
-    else if (tool === 'pocket-ic') {
+    else if (tool === "pocket-ic") {
         return pocketIc;
     }
-    else if (tool === 'wasmtime') {
+    else if (tool === "wasmtime") {
         return wasmtime;
     }
     else {
@@ -35,12 +35,14 @@ async function ensureToolchainInited({ strict = 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')))) {
+    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') {
+        let res = execSync("which moc-wrapper").toString().trim();
+        if (res && process.env.DFX_MOC_PATH === "moc-wrapper") {
             return true;
         }
     }
@@ -50,82 +52,88 @@ async function ensureToolchainInited({ strict = true } = {}) {
 }
 // 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');
+    if (process.platform == "win32") {
+        console.error("Windows is not supported. Please use WSL");
         process.exit(1);
     }
     try {
-        let res = execSync('which mocv').toString().trim();
+        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.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"');
             console.log('TIP: Alternative to "mocv use <version>" is "mops toolchain use moc <version>" (installs moc only for current project)');
-            console.log('TIP: More details at https://docs.mops.one/cli/toolchain');
+            console.log("TIP: More details at https://docs.mops.one/cli/toolchain");
             if (!process.env.CI || !silent) {
                 process.exit(1);
             }
         }
     }
     catch { }
-    let zshrc = path.join(os.homedir(), '.zshrc');
-    let bashrc = path.join(os.homedir(), '.bashrc');
-    let bashProfile = path.join(os.homedir(), '.bash_profile');
-    let zprofile = path.join(os.homedir(), '.zprofile');
-    let shellConfigFiles = [bashrc, zshrc, bashProfile, zprofile, process.env.GITHUB_ENV || ''].map(x => x).filter((file) => {
+    let zshrc = path.join(os.homedir(), ".zshrc");
+    let bashrc = path.join(os.homedir(), ".bashrc");
+    let bashProfile = path.join(os.homedir(), ".bash_profile");
+    let zprofile = path.join(os.homedir(), ".zprofile");
+    let shellConfigFiles = [
+        bashrc,
+        zshrc,
+        bashProfile,
+        zprofile,
+        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, .zshrc, .bash_profile, .zprofile');
+        console.error("Shell config files not found: .bashrc, .zshrc, .bash_profile, .zprofile");
         console.log('TIP: You can add "export DFX_MOC_PATH=moc-wrapper" to your shell config file manually to initialize Mops toolchain');
         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 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=${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, '');
+            text = text.replace(oldLine, "");
         }
-        if (text.endsWith('\n\n')) {
-            text = text.trimEnd() + '\n';
+        if (text.endsWith("\n\n")) {
+            text = text.trimEnd() + "\n";
         }
         // insert new lines
         if (!reset) {
-            if (!text.endsWith('\n')) {
-                text += '\n';
+            if (!text.endsWith("\n")) {
+                text += "\n";
             }
             for (let newLine of newLines) {
                 if (shellConfigFile === process.env.GITHUB_ENV) {
-                    newLine = newLine.replace('export ', '');
+                    newLine = newLine.replace("export ", "");
                 }
                 text += newLine;
             }
-            text += '\n';
+            text += "\n";
         }
         fs.writeFileSync(shellConfigFile, text);
     }
     if (!silent) {
-        console.log(chalk.green('Success!'));
-        console.log('Restart terminal to apply changes');
+        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);
     let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
-    silent || logUpdate('Installing', tool, version);
+    silent || logUpdate("Installing", tool, version);
     await toolUtils.download(version, { silent, verbose });
     if (verbose) {
         logUpdate.done();
@@ -151,19 +159,22 @@ async function installAll({ silent = false, verbose = false } = {}) {
             logUpdate(...args);
         }
     };
-    log('Installing toolchain...');
+    log("Installing toolchain...");
     if (config.toolchain?.moc) {
-        await download('moc', config.toolchain.moc, { silent, verbose });
+        await download("moc", config.toolchain.moc, { silent, verbose });
     }
     if (config.toolchain?.wasmtime) {
-        await download('wasmtime', config.toolchain.wasmtime, { silent, verbose });
+        await download("wasmtime", config.toolchain.wasmtime, { silent, verbose });
     }
-    if (config.toolchain?.['pocket-ic']) {
-        await download('pocket-ic', config.toolchain['pocket-ic'], { silent, verbose });
+    if (config.toolchain?.["pocket-ic"]) {
+        await download("pocket-ic", config.toolchain["pocket-ic"], {
+            silent,
+            verbose,
+        });
     }
     if (!silent) {
         logUpdate.clear();
-        console.log(chalk.green('Toolchain installed'));
+        console.log(chalk.green("Toolchain installed"));
     }
 }
 async function promptVersion(tool) {
@@ -175,13 +186,14 @@ async function promptVersion(tool) {
     let versions = releases.map((item) => item.tag_name);
     let currentIndex = versions.indexOf(current);
     let res = await prompts({
-        type: 'select',
-        name: 'version',
+        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' });
+            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)') : ''}`),
+                title: release.tag_name +
+                    chalk.gray(`  ${date}${currentIndex === i ? chalk.italic(" (current)") : ""}`),
                 value: release.tag_name,
             };
         }),
@@ -191,7 +203,7 @@ async function promptVersion(tool) {
 }
 // download binary and set version in mops.toml
 async function use(tool, version) {
-    if (tool === 'moc') {
+    if (tool === "moc") {
         await ensureToolchainInited();
     }
     if (!version) {
@@ -200,7 +212,7 @@ async function use(tool, version) {
     if (!version) {
         return;
     }
-    if (version === 'latest') {
+    if (version === "latest") {
         version = await getToolUtils(tool).getLatestReleaseTag();
     }
     await download(tool, version);
@@ -211,7 +223,7 @@ async function use(tool, version) {
     writeConfig(config);
     await checkRequirements();
     if (oldVersion === version) {
-        console.log((`${tool} ${version} is already installed`));
+        console.log(`${tool} ${version} is already installed`);
     }
     else {
         console.log(chalk.green(`Installed ${tool} ${version}`));
@@ -219,7 +231,7 @@ async function use(tool, version) {
 }
 // download latest binary and set version in mops.toml
 async function update(tool) {
-    if (tool === 'moc') {
+    if (tool === "moc") {
         await ensureToolchainInited();
     }
     let config = readConfig();
@@ -236,11 +248,11 @@ async function update(tool) {
         let oldVersion = config.toolchain[tool];
         config.toolchain[tool] = version;
         writeConfig(config);
-        if (tool === 'moc') {
+        if (tool === "moc") {
             await checkRequirements();
         }
         if (oldVersion === version) {
-            console.log((`Latest ${tool} ${version} is already installed`));
+            console.log(`Latest ${tool} ${version} is already installed`);
         }
         else {
             console.log(chalk.green(`Installed ${tool} ${version}`));
@@ -252,8 +264,8 @@ 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';
+        if (tool === "moc" && fallback) {
+            return execSync("dfx cache show").toString().trim() + "/moc";
         }
         checkConfigFile();
         process.exit(1);
@@ -261,12 +273,12 @@ async function bin(tool, { fallback = false } = {}) {
     let config = readConfig();
     let version = config.toolchain?.[tool];
     if (version) {
-        if (tool === 'moc') {
+        if (tool === "moc") {
             await ensureToolchainInited();
         }
         await download(tool, version, { silent: true });
-        if (tool === 'moc') {
-            return path.join(globalCacheDir, 'moc', version, tool);
+        if (tool === "moc") {
+            return path.join(globalCacheDir, "moc", version, tool);
         }
         else {
             return path.join(globalCacheDir, tool, version, tool);
@@ -274,8 +286,8 @@ async function bin(tool, { fallback = false } = {}) {
     }
     else {
         // fallback to dfx moc
-        if (tool === 'moc' && fallback) {
-            return execSync('dfx cache show').toString().trim() + '/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`);

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

@@ -1,7 +1,7 @@
 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 isCached: (version: string, filename: "moc" | "moc.js") => boolean;
 export declare let download: (version: string, { silent, verbose }?: {
     silent?: boolean | undefined;
     verbose?: boolean | undefined;

package/dist/commands/toolchain/moc.js

@@ -1,55 +1,79 @@
-import process from 'node:process';
-import path from 'node:path';
-import fs from 'fs-extra';
-import { SemVer } from 'semver';
-import { globalCacheDir } from '../../mops.js';
-import * as toolchainUtils from './toolchain-utils.js';
-let cacheDir = path.join(globalCacheDir, 'moc');
-export let repo = 'dfinity/motoko';
+import process from "node:process";
+import path from "node:path";
+import fs from "fs-extra";
+import { SemVer } from "semver";
+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) => {
+export let isCached = (version, filename) => {
     let dir = path.join(cacheDir, version);
-    return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'moc'));
+    return fs.existsSync(dir) && fs.existsSync(path.join(dir, filename));
 };
 export let download = async (version, { silent = false, verbose = false } = {}) => {
-    if (process.platform == 'win32') {
-        console.error('Windows is not supported. Please use WSL');
+    if (process.platform == "win32") {
+        console.error("Windows is not supported. Please use WSL");
         process.exit(1);
     }
     if (!version) {
-        console.error('version is not defined');
+        console.error("version is not defined");
         process.exit(1);
     }
-    if (isCached(version)) {
+    const destDir = path.join(cacheDir, version);
+    if (isCached(version, "moc.js")) {
+        if (verbose) {
+            console.log(`moc.js ${version} is already downloaded`);
+        }
+    }
+    else {
+        // Download the .js artifact
+        const jsUrl = `https://github.com/dfinity/motoko/releases/download/${version}/moc-${version}.js`;
+        const jsDestPath = path.join(destDir, "moc.js");
+        if (verbose && !silent) {
+            console.log(`Downloading ${jsUrl}`);
+        }
+        const buffer = await toolchainUtils.tryDownloadFile(jsUrl);
+        if (buffer) {
+            fs.mkdirSync(destDir, { recursive: true });
+            fs.writeFileSync(jsDestPath, buffer);
+        }
+        else if (verbose && !silent) {
+            console.log(`Warning: Could not download ${jsUrl}`);
+        }
+    }
+    if (isCached(version, "moc")) {
         if (verbose) {
             console.log(`moc ${version} is already installed`);
         }
         return;
     }
     let url;
-    if (new SemVer(version).compare(new SemVer('0.14.6')) >= 0) {
-        let platfrom = process.platform == 'darwin' ? 'Darwin' : 'Linux';
-        let arch = process.arch.startsWith('arm')
-            ? (process.platform == 'darwin' ? 'arm64' : 'aarch64')
-            : 'x86_64';
+    if (new SemVer(version).compare(new SemVer("0.14.6")) >= 0) {
+        let platfrom = process.platform == "darwin" ? "Darwin" : "Linux";
+        let arch = process.arch.startsWith("arm")
+            ? process.platform == "darwin"
+                ? "arm64"
+                : "aarch64"
+            : "x86_64";
         url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
     }
-    else if (new SemVer(version).compare(new SemVer('0.9.5')) >= 0) {
-        let platfrom = process.platform == 'darwin' ? 'Darwin' : 'Linux';
-        let arch = 'x86_64';
+    else if (new SemVer(version).compare(new SemVer("0.9.5")) >= 0) {
+        let platfrom = process.platform == "darwin" ? "Darwin" : "Linux";
+        let 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';
+        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));
+    await toolchainUtils.downloadAndExtract(url, destDir);
 };

package/dist/commands/toolchain/pocket-ic.js

@@ -1,10 +1,10 @@
-import process from 'node:process';
-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';
+import process from "node:process";
+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 toolchainUtils.getLatestReleaseTag(repo);
 };
@@ -13,11 +13,11 @@ export let getReleases = async () => {
 };
 export let isCached = (version) => {
     let dir = path.join(cacheDir, version);
-    return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'pocket-ic'));
+    return fs.existsSync(dir) && fs.existsSync(path.join(dir, "pocket-ic"));
 };
 export let download = async (version, { silent = false, verbose = false } = {}) => {
     if (!version) {
-        console.error('version is not defined');
+        console.error("version is not defined");
         process.exit(1);
     }
     if (isCached(version)) {
@@ -26,11 +26,11 @@ export let download = async (version, { silent = false, verbose = false } = {})
         }
         return;
     }
-    let platfrom = process.platform == 'darwin' ? 'darwin' : 'linux';
-    let arch = 'x86_64';
+    let platfrom = process.platform == "darwin" ? "darwin" : "linux";
+    let arch = "x86_64";
     let url = `https://github.com/dfinity/pocketic/releases/download/${version}/pocket-ic-${arch}-${platfrom}.gz`;
     if (verbose && !silent) {
         console.log(`Downloading ${url}`);
     }
-    await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version), 'pocket-ic');
+    await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version), "pocket-ic");
 };

package/dist/commands/toolchain/toolchain-utils.d.ts

@@ -1,3 +1,5 @@
+import { Buffer } from "node:buffer";
+export declare let tryDownloadFile: (url: string) => Promise<Buffer | null>;
 export declare let downloadAndExtract: (url: string, destDir: string, destFileName?: string) => Promise<void>;
 export declare let getLatestReleaseTag: (repo: string) => Promise<string>;
 export declare let getReleases: (repo: string) => Promise<any>;

package/dist/commands/toolchain/toolchain-utils.js

@@ -1,16 +1,25 @@
-import process from 'node:process';
-import path from 'node:path';
-import { Buffer } from 'node:buffer';
-import { unzipSync } from 'node:zlib';
-import { chmodSync } from 'node:fs';
-import fs from 'fs-extra';
-import decompress from 'decompress';
+import process from "node:process";
+import path from "node:path";
+import { Buffer } from "node:buffer";
+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 { extract as extractTar } from 'tar';
-import { getRootDir } from '../../mops.js';
-export let downloadAndExtract = async (url, destDir, destFileName = '') => {
+import { deleteSync } from "del";
+import { Octokit } from "octokit";
+import { extract as extractTar } from "tar";
+import { getRootDir } from "../../mops.js";
+export let tryDownloadFile = async (url) => {
+    let res = await fetch(url);
+    if (!res.ok) {
+        console.error(`HTTP ${res.status} ${url}`);
+        return null;
+    }
+    let arrayBuffer = await res.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+};
+export let downloadAndExtract = async (url, destDir, destFileName = "") => {
     let res = await fetch(url);
     if (res.status !== 200) {
         console.error(`ERROR ${res.status} ${url}`);
@@ -18,27 +27,27 @@ export let downloadAndExtract = async (url, destDir, destFileName = '') => {
     }
     let arrayBuffer = await res.arrayBuffer();
     let buffer = Buffer.from(arrayBuffer);
-    let tmpDir = path.join(getRootDir(), '.mops', '_tmp');
+    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(destDir, { recursive: true });
-    if (archive.endsWith('.xz')) {
-        let decompressTarxz = await import('decomp-tarxz');
+    if (archive.endsWith(".xz")) {
+        let decompressTarxz = await import("decomp-tarxz");
         await decompress(archive, tmpDir, {
             plugins: [decompressTarxz.default()],
         }).catch(() => {
             deleteSync([tmpDir]);
         });
-        fs.cpSync(path.join(tmpDir, path.parse(archive).name.replace('.tar', '')), destDir, { recursive: true });
+        fs.cpSync(path.join(tmpDir, path.parse(archive).name.replace(".tar", "")), destDir, { recursive: true });
     }
-    else if (archive.endsWith('tar.gz')) {
+    else if (archive.endsWith("tar.gz")) {
         await extractTar({
             file: archive,
             cwd: destDir,
         });
     }
-    else if (archive.endsWith('.gz')) {
+    else if (archive.endsWith(".gz")) {
         let destFile = path.join(destDir, destFileName || path.parse(archive).name);
         fs.writeFileSync(destFile, unzipSync(buffer));
         chmodSync(destFile, 0o700);
@@ -52,24 +61,24 @@ export let getLatestReleaseTag = async (repo) => {
         console.error(`Failed to fetch latest release tag for ${repo}`);
         process.exit(1);
     }
-    return release.tag_name.replace(/^v/, '');
+    return release.tag_name.replace(/^v/, "");
 };
 export let getReleases = async (repo) => {
-    let octokit = new Octokit;
+    let octokit = new Octokit();
     let res = await octokit.request(`GET /repos/${repo}/releases`, {
         per_page: 10,
         headers: {
-            'X-GitHub-Api-Version': '2022-11-28',
+            "X-GitHub-Api-Version": "2022-11-28",
         },
     });
     if (res.status !== 200) {
-        console.log('Releases fetch error');
+        console.log("Releases fetch error");
         process.exit(1);
     }
     return res.data.map((release) => {
         return {
             ...release,
-            tag_name: release.tag_name.replace(/^v/, ''),
+            tag_name: release.tag_name.replace(/^v/, ""),
         };
     });
 };

package/dist/commands/toolchain/wasmtime.js

@@ -1,10 +1,10 @@
-import process from 'node:process';
-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';
+import process from "node:process";
+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);
 };
@@ -13,11 +13,11 @@ export let getReleases = async () => {
 };
 export let isCached = (version) => {
     let dir = path.join(cacheDir, version);
-    return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'wasmtime'));
+    return fs.existsSync(dir) && fs.existsSync(path.join(dir, "wasmtime"));
 };
 export let download = async (version, { silent = false, verbose = false } = {}) => {
     if (!version) {
-        console.error('version is not defined');
+        console.error("version is not defined");
         process.exit(1);
     }
     if (isCached(version)) {
@@ -26,8 +26,8 @@ export let download = async (version, { silent = false, verbose = false } = {})
         }
         return;
     }
-    let platfrom = process.platform == 'darwin' ? 'macos' : 'linux';
-    let arch = process.arch.startsWith('arm') ? 'aarch64' : 'x86_64';
+    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}`);

package/dist/commands/update.d.ts

@@ -1,7 +1,7 @@
 type UpdateOptions = {
     verbose?: boolean;
     dev?: boolean;
-    lock?: 'update' | 'ignore';
+    lock?: "update" | "ignore";
 };
 export declare function update(pkg?: string, { lock }?: UpdateOptions): Promise<void>;
 export {};