ic-mops 1.11.1 → 2.0.0

package/commands/toolchain/moc.ts

@@ -1,65 +1,93 @@
-import process from 'node:process';
-import path from 'node:path';
-import fs from 'fs-extra';
-import {SemVer} from 'semver';
+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';
+import { globalCacheDir } from "../../mops.js";
+import * as toolchainUtils from "./toolchain-utils.js";
 
-let cacheDir = path.join(globalCacheDir, 'moc');
+let cacheDir = path.join(globalCacheDir, "moc");
 
-export let repo = 'dfinity/motoko';
+export let repo = "dfinity/motoko";
 
 export let getLatestReleaseTag = async () => {
-	return toolchainUtils.getLatestReleaseTag(repo);
+  return toolchainUtils.getLatestReleaseTag(repo);
 };
 
 export let getReleases = async () => {
-	return toolchainUtils.getReleases(repo);
+  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 isCached = (version: string, filename: "moc" | "moc.js") => {
+  let dir = path.join(cacheDir, version);
+  return fs.existsSync(dir) && fs.existsSync(path.join(dir, filename));
 };
 
-export let download = async (version : string, {silent = false, verbose = false} = {}) => {
-	if (process.platform == 'win32') {
-		console.error('Windows is not supported. Please use WSL');
-		process.exit(1);
-	}
-	if (!version) {
-		console.error('version is not defined');
-		process.exit(1);
-	}
-	if (isCached(version)) {
-		if (verbose) {
-			console.log(`moc ${version} is already installed`);
-		}
-		return;
-	}
+export let download = async (
+  version: string,
+  { silent = false, verbose = false } = {},
+) => {
+  if (process.platform == "win32") {
+    console.error("Windows is not supported. Please use WSL");
+    process.exit(1);
+  }
+  if (!version) {
+    console.error("version is not defined");
+    process.exit(1);
+  }
 
-	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';
-		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';
-		url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
-	}
-	else {
-		let platfrom = process.platform == 'darwin' ? 'macos' : 'linux64';
-		url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
-	}
+  const destDir = path.join(cacheDir, version);
 
-	if (verbose && !silent) {
-		console.log(`Downloading ${url}`);
-	}
+  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");
 
-	await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
-};
+    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";
+    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";
+    url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+  } else {
+    let platfrom = process.platform == "darwin" ? "macos" : "linux64";
+    url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
+  }
+
+  if (verbose && !silent) {
+    console.log(`Downloading ${url}`);
+  }
+
+  await toolchainUtils.downloadAndExtract(url, destDir);
+};

package/commands/toolchain/pocket-ic.ts

@@ -1,46 +1,53 @@
-import process from 'node:process';
-import path from 'node:path';
-import fs from 'node:fs';
+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';
+import { globalCacheDir } from "../../mops.js";
+import * as toolchainUtils from "./toolchain-utils.js";
 
-let cacheDir = path.join(globalCacheDir, 'pocket-ic');
+let cacheDir = path.join(globalCacheDir, "pocket-ic");
 
-export let repo = 'dfinity/pocketic';
+export let repo = "dfinity/pocketic";
 
 export let getLatestReleaseTag = async () => {
-	return toolchainUtils.getLatestReleaseTag(repo);
+  return toolchainUtils.getLatestReleaseTag(repo);
 };
 
 export let getReleases = async () => {
-	return toolchainUtils.getReleases(repo);
+  return toolchainUtils.getReleases(repo);
 };
 
-export let isCached = (version : string) => {
-	let dir = path.join(cacheDir, version);
-	return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'pocket-ic'));
+export let isCached = (version: string) => {
+  let dir = path.join(cacheDir, version);
+  return fs.existsSync(dir) && fs.existsSync(path.join(dir, "pocket-ic"));
 };
 
-export let download = async (version : string, {silent = false, verbose = false} = {}) => {
-	if (!version) {
-		console.error('version is not defined');
-		process.exit(1);
-	}
-	if (isCached(version)) {
-		if (verbose) {
-			console.log(`pocket-ic ${version} is already installed`);
-		}
-		return;
-	}
-
-	let platfrom = process.platform == 'darwin' ? 'darwin' : 'linux';
-	let arch = 'x86_64';
-	let 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');
-};
+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(`pocket-ic ${version} is already installed`);
+    }
+    return;
+  }
+
+  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",
+  );
+};

package/commands/toolchain/toolchain-utils.ts

@@ -1,86 +1,106 @@
-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 { deleteSync } from "del";
+import { Octokit } from "octokit";
+import { extract as extractTar } from "tar";
 
-import {getRootDir} from '../../mops.js';
+import { getRootDir } from "../../mops.js";
 
-export let downloadAndExtract = async (url : string, destDir : string, destFileName : string = '') => {
-	let res = await fetch(url);
+export let tryDownloadFile = async (url: string): Promise<Buffer | null> => {
+  let res = await fetch(url);
 
-	if (res.status !== 200) {
-		console.error(`ERROR ${res.status} ${url}`);
-		process.exit(1);
-	}
+  if (!res.ok) {
+    console.error(`HTTP ${res.status} ${url}`);
+    return null;
+  }
 
-	let arrayBuffer = await res.arrayBuffer();
-	let buffer = Buffer.from(arrayBuffer);
+  let arrayBuffer = await res.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+};
+
+export let downloadAndExtract = async (
+  url: string,
+  destDir: string,
+  destFileName: string = "",
+) => {
+  let res = await fetch(url);
+
+  if (res.status !== 200) {
+    console.error(`ERROR ${res.status} ${url}`);
+    process.exit(1);
+  }
 
-	let tmpDir = path.join(getRootDir(), '.mops', '_tmp');
-	let archive = path.join(tmpDir, path.basename(url));
+  let arrayBuffer = await res.arrayBuffer();
+  let buffer = Buffer.from(arrayBuffer);
 
-	fs.mkdirSync(tmpDir, {recursive: true});
-	fs.writeFileSync(archive, buffer);
+  let tmpDir = path.join(getRootDir(), ".mops", "_tmp");
+  let archive = path.join(tmpDir, path.basename(url));
 
-	fs.mkdirSync(destDir, {recursive: true});
+  fs.mkdirSync(tmpDir, { recursive: true });
+  fs.writeFileSync(archive, buffer);
 
-	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});
-	}
-	else if (archive.endsWith('tar.gz')) {
-		await extractTar({
-			file: archive,
-			cwd: destDir,
-		});
-	}
-	else if (archive.endsWith('.gz')) {
-		let destFile = path.join(destDir, destFileName || path.parse(archive).name);
-		fs.writeFileSync(destFile, unzipSync(buffer));
-		chmodSync(destFile, 0o700);
-	}
+  fs.mkdirSync(destDir, { recursive: true });
 
-	deleteSync([tmpDir], {force: true});
+  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 },
+    );
+  } else if (archive.endsWith("tar.gz")) {
+    await extractTar({
+      file: archive,
+      cwd: destDir,
+    });
+  } else if (archive.endsWith(".gz")) {
+    let destFile = path.join(destDir, destFileName || path.parse(archive).name);
+    fs.writeFileSync(destFile, unzipSync(buffer));
+    chmodSync(destFile, 0o700);
+  }
+
+  deleteSync([tmpDir], { force: true });
 };
 
-export let getLatestReleaseTag = async (repo : string) : Promise<string> => {
-	let releases = await getReleases(repo);
-	let release = releases.find((release : any) => !release.prerelease && !release.draft);
-	if (!release?.tag_name) {
-		console.error(`Failed to fetch latest release tag for ${repo}`);
-		process.exit(1);
-	}
-	return release.tag_name.replace(/^v/, '');
+export let getLatestReleaseTag = async (repo: string): Promise<string> => {
+  let releases = await getReleases(repo);
+  let release = releases.find(
+    (release: any) => !release.prerelease && !release.draft,
+  );
+  if (!release?.tag_name) {
+    console.error(`Failed to fetch latest release tag for ${repo}`);
+    process.exit(1);
+  }
+  return release.tag_name.replace(/^v/, "");
 };
 
-export let getReleases = async (repo : string) => {
-	let octokit = new Octokit;
-	let res = await octokit.request(`GET /repos/${repo}/releases`, {
-		per_page: 10,
-		headers: {
-			'X-GitHub-Api-Version': '2022-11-28',
-		},
-	});
-	if (res.status !== 200) {
-		console.log('Releases fetch error');
-		process.exit(1);
-	}
-	return res.data.map((release : any) => {
-		return {
-			...release,
-			tag_name: release.tag_name.replace(/^v/, ''),
-		};
-	});
-};
+export let getReleases = async (repo: string) => {
+  let octokit = new Octokit();
+  let res = await octokit.request(`GET /repos/${repo}/releases`, {
+    per_page: 10,
+    headers: {
+      "X-GitHub-Api-Version": "2022-11-28",
+    },
+  });
+  if (res.status !== 200) {
+    console.log("Releases fetch error");
+    process.exit(1);
+  }
+  return res.data.map((release: any) => {
+    return {
+      ...release,
+      tag_name: release.tag_name.replace(/^v/, ""),
+    };
+  });
+};

package/commands/toolchain/wasmtime.ts

@@ -1,46 +1,49 @@
-import process from 'node:process';
-import path from 'node:path';
-import fs from 'fs-extra';
+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';
+import { globalCacheDir } from "../../mops.js";
+import * as toolchainUtils from "./toolchain-utils.js";
 
-let cacheDir = path.join(globalCacheDir, 'wasmtime');
+let cacheDir = path.join(globalCacheDir, "wasmtime");
 
-export let repo = 'bytecodealliance/wasmtime';
+export let repo = "bytecodealliance/wasmtime";
 
 export let getLatestReleaseTag = async () => {
-	return toolchainUtils.getLatestReleaseTag(repo);
+  return toolchainUtils.getLatestReleaseTag(repo);
 };
 
 export let getReleases = async () => {
-	return toolchainUtils.getReleases(repo);
+  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 isCached = (version: string) => {
+  let dir = path.join(cacheDir, version);
+  return fs.existsSync(dir) && fs.existsSync(path.join(dir, "wasmtime"));
 };
 
-export let download = async (version : string, {silent = false, verbose = false} = {}) => {
-	if (!version) {
-		console.error('version is not defined');
-		process.exit(1);
-	}
-	if (isCached(version)) {
-		if (verbose) {
-			console.log(`wasmtime ${version} is already installed`);
-		}
-		return;
-	}
-
-	let platfrom = process.platform == 'darwin' ? 'macos' : 'linux';
-	let arch = process.arch.startsWith('arm') ? 'aarch64' : 'x86_64';
-	let url = `https://github.com/bytecodealliance/wasmtime/releases/download/v${version}/wasmtime-v${version}-${arch}-${platfrom}.tar.xz`;
-
-	if (verbose && !silent) {
-		console.log(`Downloading ${url}`);
-	}
-
-	await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
-};
+export let download = async (
+  version: string,
+  { silent = false, verbose = false } = {},
+) => {
+  if (!version) {
+    console.error("version is not defined");
+    process.exit(1);
+  }
+  if (isCached(version)) {
+    if (verbose) {
+      console.log(`wasmtime ${version} is already installed`);
+    }
+    return;
+  }
+
+  let platfrom = process.platform == "darwin" ? "macos" : "linux";
+  let arch = process.arch.startsWith("arm") ? "aarch64" : "x86_64";
+  let url = `https://github.com/bytecodealliance/wasmtime/releases/download/v${version}/wasmtime-v${version}-${arch}-${platfrom}.tar.xz`;
+
+  if (verbose && !silent) {
+    console.log(`Downloading ${url}`);
+  }
+
+  await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version));
+};

package/commands/update.ts

@@ -1,60 +1,95 @@
-import chalk from 'chalk';
-import {checkConfigFile, getGithubCommit, parseGithubURL, readConfig} from '../mops.js';
-import {add} from './add.js';
-import {getAvailableUpdates} from './available-updates.js';
-import {checkIntegrity} from '../integrity.js';
+import chalk from "chalk";
+import {
+  checkConfigFile,
+  getGithubCommit,
+  parseGithubURL,
+  readConfig,
+} from "../mops.js";
+import { add } from "./add.js";
+import { getAvailableUpdates } from "./available-updates.js";
+import { checkIntegrity } from "../integrity.js";
+import { getDepName, getDepPinnedVersion } from "../helpers/get-dep-name.js";
 
 type UpdateOptions = {
-	verbose ?: boolean;
-	dev ?: boolean;
-	lock ?: 'update' | 'ignore';
+  verbose?: boolean;
+  dev?: boolean;
+  lock?: "update" | "ignore";
 };
 
-export async function update(pkg ?: string, {lock} : UpdateOptions = {}) {
-	if (!checkConfigFile()) {
-		return;
-	}
-	let config = readConfig();
-
-	if (pkg && !config.dependencies?.[pkg] && !config['dev-dependencies']?.[pkg]) {
-		console.log(chalk.red(`Package "${pkg}" is not installed!`));
-		return;
-	}
-
-	// update github packages
-	let deps = Object.values(config.dependencies || {});
-	let devDeps = Object.values(config['dev-dependencies'] || {});
-	let githubDeps = [...deps, ...devDeps].filter((dep) => dep.repo);
-	if (pkg) {
-		githubDeps = githubDeps.filter((dep) => dep.name === pkg);
-	}
-
-	for (let dep of githubDeps) {
-		let {org, gitName, branch, commitHash} = parseGithubURL(dep.repo || '');
-		let dev = !!config['dev-dependencies']?.[dep.name];
-		let commit = await getGithubCommit(`${org}/${gitName}`, branch);
-		if (commit.sha !== commitHash) {
-			await add(`https://github.com/${org}/${gitName}#${branch}@${commit.sha}`, {dev}, dep.name);
-		}
-	}
-
-	// update mops packages
-	let available = await getAvailableUpdates(config, pkg);
-
-	if (available.length === 0) {
-		if (pkg) {
-			console.log(chalk.green(`Package "${pkg}" is up to date!`));
-		}
-		else {
-			console.log(chalk.green('All dependencies are up to date!'));
-		}
-	}
-	else {
-		for (let dep of available) {
-			let dev = !!config['dev-dependencies']?.[dep[0]];
-			await add(`${dep[0]}@${dep[2]}`, {dev});
-		}
-	}
-
-	await checkIntegrity(lock);
-}
+export async function update(pkg?: string, { lock }: UpdateOptions = {}) {
+  if (!checkConfigFile()) {
+    return;
+  }
+  let config = readConfig();
+
+  if (
+    pkg &&
+    !config.dependencies?.[pkg] &&
+    !config["dev-dependencies"]?.[pkg]
+  ) {
+    console.log(chalk.red(`Package "${pkg}" is not installed!`));
+    return;
+  }
+
+  // update github packages
+  let deps = Object.values(config.dependencies || {});
+  let devDeps = Object.values(config["dev-dependencies"] || {});
+  let githubDeps = [...deps, ...devDeps].filter((dep) => dep.repo);
+  if (pkg) {
+    githubDeps = githubDeps.filter((dep) => dep.name === pkg);
+  }
+
+  for (let dep of githubDeps) {
+    let { org, gitName, branch, commitHash } = parseGithubURL(dep.repo || "");
+    let dev = !!config["dev-dependencies"]?.[dep.name];
+    let commit = await getGithubCommit(`${org}/${gitName}`, branch);
+    if (commit.sha !== commitHash) {
+      await add(
+        `https://github.com/${org}/${gitName}#${branch}@${commit.sha}`,
+        { dev },
+        dep.name,
+      );
+    }
+  }
+
+  // update mops packages
+  let available = await getAvailableUpdates(config, pkg);
+
+  if (available.length === 0) {
+    if (pkg) {
+      console.log(chalk.green(`Package "${pkg}" is up to date!`));
+    } else {
+      console.log(chalk.green("All dependencies are up to date!"));
+    }
+  } else {
+    for (let dep of available) {
+      let devDeps = Object.keys(config["dev-dependencies"] || {});
+      let allDeps = [...Object.keys(config.dependencies || {}), ...devDeps];
+
+      let dev = false;
+      for (let d of devDeps) {
+        let pinnedVersion = getDepPinnedVersion(d);
+        if (
+          getDepName(d) === dep[0] &&
+          (!pinnedVersion || dep[1].startsWith(pinnedVersion))
+        ) {
+          dev = true;
+          break;
+        }
+      }
+
+      let asName =
+        allDeps.find((d) => {
+          let pinnedVersion = getDepPinnedVersion(d);
+          return (
+            getDepName(d) === dep[0] &&
+            (!pinnedVersion || dep[1].startsWith(pinnedVersion))
+          );
+        }) || dep[0];
+
+      await add(`${dep[0]}@${dep[2]}`, { dev }, asName);
+    }
+  }
+
+  await checkIntegrity(lock);
+}