ic-mops 0.39.2 → 0.41.0

package/mops.ts

@@ -74,8 +74,8 @@ if (fs.existsSync(oldGlobalConfigDir) && !fs.existsSync(globalCacheDir)) {
 }
 
 
-export function getNetworkFile(): string | URL {
-	let networkFile: string | URL = '';
+export function getNetworkFile() : string | URL {
+	let networkFile : string | URL = '';
 	try {
 		networkFile = new URL('./network.txt', import.meta.url);
 	}
@@ -85,18 +85,18 @@ export function getNetworkFile(): string | URL {
 	return networkFile;
 }
 
-export function setNetwork(network: string) {
+export function setNetwork(network : string) {
 	fs.writeFileSync(getNetworkFile(), network);
 }
 
-export let getIdentity = async (): Promise<Identity | undefined> => {
+export let getIdentity = async () : Promise<Identity | undefined> => {
 	let identityPem = path.resolve(globalConfigDir, 'identity.pem');
 	let identityPemEncrypted = path.resolve(globalConfigDir, 'identity.pem.encrypted');
 	if (fs.existsSync(identityPemEncrypted)) {
 		let res = await prompts({
 			type: 'invisible',
 			name: 'value',
-			message: 'Enter password:'
+			message: 'Enter password:',
 		});
 		return await decodeFile(identityPemEncrypted, res.value);
 	}
@@ -134,12 +134,12 @@ export function checkConfigFile() {
 	return true;
 }
 
-export function progressBar(step: number, total: number) {
+export function progressBar(step : number, total : number) {
 	let done = Math.round(step / total * 10);
 	return `[${':'.repeat(done)}${' '.repeat(Math.max(0, 10 - done))}]`;
 }
 
-export function parseGithubURL(href: string) {
+export function parseGithubURL(href : string) {
 	const url = new URL(href);
 	let branchAndSha = url.hash?.substring(1).split('@');
 	let branch = branchAndSha[0] || 'master';
@@ -154,9 +154,9 @@ export function parseGithubURL(href: string) {
 	return {org, gitName, branch, commitHash};
 }
 
-export async function getGithubCommit(repo: string, ref: string): Promise<any> {
+export async function getGithubCommit(repo : string, ref : string) : Promise<any> {
 	let res = await fetch(`https://api.github.com/repos/${repo}/commits/${ref}`);
-	let json: any = await res.json();
+	let json : any = await res.json();
 
 	// try on main branch
 	if (json.message && ref === 'master') {
@@ -166,7 +166,7 @@ export async function getGithubCommit(repo: string, ref: string): Promise<any> {
 	return json;
 }
 
-export function getDependencyType(version: string) {
+export function getDependencyType(version : string) {
 	if (!version || typeof version !== 'string') {
 		throw Error(`Invalid dependency value "${version}"`);
 	}
@@ -181,11 +181,11 @@ export function getDependencyType(version: string) {
 	}
 }
 
-export function readConfig(configFile = getClosestConfigFile()): Config {
+export function readConfig(configFile = getClosestConfigFile()) : Config {
 	let text = fs.readFileSync(configFile).toString();
 	let toml = TOML.parse(text);
 
-	let processDeps = (deps: any) => {
+	let processDeps = (deps : any) => {
 		Object.entries(deps).forEach(([name, data]) => {
 			if (!data || typeof data !== 'string') {
 				throw Error(`Invalid dependency value ${name} = "${data}"`);
@@ -209,8 +209,8 @@ export function readConfig(configFile = getClosestConfigFile()): Config {
 	return toml;
 }
 
-export function writeConfig(config: Config, configFile = getClosestConfigFile()) {
-	let resConfig: any = JSON.parse(JSON.stringify(config));
+export function writeConfig(config : Config, configFile = getClosestConfigFile()) {
+	let resConfig : any = JSON.parse(JSON.stringify(config));
 
 	let deps = resConfig.dependencies || {};
 	Object.entries(config.dependencies || {}).forEach(([name, {repo, path, version}]) => {
@@ -229,16 +229,16 @@ export function writeConfig(config: Config, configFile = getClosestConfigFile())
 	fs.writeFileSync(configFile, text);
 }
 
-export function formatDir(name: string, version: string) {
+export function formatDir(name : string, version : string) {
 	return path.join(getRootDir(), '.mops', `${name}@${version}`);
 }
 
-export function formatGithubDir(name: string, repo: string) {
+export function formatGithubDir(name : string, repo : string) {
 	const {branch, commitHash} = parseGithubURL(repo);
 	return path.join(getRootDir(), '.mops/_github', `${name}#${branch}` + (commitHash ? `@${commitHash}` : ''));
 }
 
-export function readDfxJson(): any {
+export function readDfxJson() : any {
 	let dir = process.cwd();
 	let dfxJson = null;
 	for (let i = 0; i < 5; i++) {
@@ -271,6 +271,11 @@ export async function checkApiCompatibility() {
 	return true;
 }
 
+export function version() {
+	let packageJson = JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url)).toString());
+	return packageJson.version;
+}
+
 // compatibility with older versions
 export {
 	getNetwork,

package/notify-installs.ts

@@ -2,9 +2,9 @@ import {getDependencyType} from './mops.js';
 import {mainActor} from './api/actors.js';
 import {resolvePackages} from './resolve-packages.js';
 
-export async function notifyInstalls(names: string[]) {
+export async function notifyInstalls(names : string[]) {
 	let resolvedPackages = await resolvePackages();
-	let packages: [string, string][] = names.map(name => [name, resolvedPackages[name] as string]);
+	let packages : [string, string][] = names.map(name => [name, resolvedPackages[name] as string]);
 	if (packages.length) {
 		let actor = await mainActor();
 		await actor.notifyInstalls(packages.filter(([_, version]) => getDependencyType(version) === 'mops'));

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "ic-mops",
-  "version": "0.39.2",
+  "version": "0.41.0",
   "type": "module",
   "bin": {
-    "mops": "dist/bin/mops.js",
-    "ic-mops": "dist/bin/mops.js",
+    "mops": "bin/mops.js",
+    "ic-mops": "bin/mops.js",
     "moc-wrapper": "bin/moc-wrapper.sh"
   },
   "files": [
@@ -25,10 +25,15 @@
   },
   "scripts": {
     "build": "tsc",
-    "bundle": "esbuild --bundle --outfile=cli.js --platform=node --packages=external --target=node16 --format=esm ./dist/cli.js",
-    "copy": "cp -r commands/bench dist/commands && cp -r declarations templates network.txt package.json dist | true",
-    "save-network": "cp -r dist/network.txt . | true",
-    "prepare": "npm run save-network && npm run build && npm run copy",
+    "bundle": "rm -rf ./bundle && bun build ./cli.ts --outdir ./bundle --target node --minify --external @napi-rs/lzma --external fsevents --format esm --define '__dirname=import.meta.dirname' && npm run bundle:fix && npm run bundle:copy && npm run bundle:package-json && npm run bundle:tar",
+    "bundle:fix": "npx -y rexreplace 'new URL\\(\"\\.\\./templates' 'new URL(\"./templates' bundle/cli.js",
+    "bundle:copy": "cp -r commands/bench bundle && cp -r bin declarations templates package.json bundle",
+    "bundle:package-json": "tsx bundle-package-json.ts",
+    "bundle:tar": "tar -czvf bundle/cli.tgz bundle",
+    "copy": "cp -r commands/bench dist/commands && cp -r declarations templates package.json bin dist | true",
+    "prepare": "npm run build && npm run copy && npm run remove-scripts",
+    "remove-scripts": "tsx ./remove-scripts.ts",
+    "release": "tsx release-cli.ts",
     "check": "tsc --project tsconfig.json --noEmit",
     "tsc": "tsc",
     "esbuild": "esbuild"
@@ -42,18 +47,19 @@
     "@iarna/toml": "^2.2.5",
     "@noble/hashes": "1.3.2",
     "as-table": "^1.0.55",
+    "buffer": "6.0.3",
     "cacheable-request": "10.2.12",
     "camelcase": "^7.0.1",
     "chalk": "^5.3.0",
-    "chokidar": "^3.5.3",
-    "commander": "11.1.0",
+    "chokidar": "3.6.0",
+    "commander": "12.0.0",
     "debounce": "^1.2.1",
     "decomp-tarxz": "0.1.1",
     "decompress": "^4.2.1",
-    "del": "^7.0.0",
+    "del": "7.1.0",
     "dhall-to-json-cli": "^1.7.6",
-    "eslint": "^8.45.0",
-    "execa": "7.1.1",
+    "eslint": "8.57.0",
+    "execa": "8.0.1",
     "fs-extra": "11.2.0",
     "get-folder-size": "^4.0.0",
     "glob": "^10.3.3",
@@ -70,24 +76,27 @@
     "pem-file": "^1.0.1",
     "pic-ic": "0.3.2",
     "prompts": "^2.4.2",
+    "semver": "7.6.0",
     "stream-to-promise": "^3.0.0",
-    "string-width": "7.0.0",
-    "tar": "^6.1.15"
+    "string-width": "7.1.0",
+    "tar": "6.2.0"
   },
   "devDependencies": {
-    "@tsconfig/strictest": "^2.0.1",
+    "@tsconfig/strictest": "2.0.2",
     "@types/debounce": "^1.2.1",
     "@types/decompress": "^4.2.4",
     "@types/fs-extra": "11.0.4",
     "@types/glob": "^8.1.0",
     "@types/ncp": "^2.0.5",
-    "@types/node": "^20.4.4",
+    "@types/node": "20.11.24",
     "@types/prompts": "^2.4.4",
+    "@types/semver": "7.5.8",
     "@types/stream-to-promise": "^2.2.1",
     "@types/tar": "^6.1.5",
-    "esbuild": "^0.18.16",
-    "tsx": "4.6.2",
-    "typescript": "^5.1.6"
+    "bun": "1.0.35",
+    "esbuild": "0.20.1",
+    "tsx": "4.7.1",
+    "typescript": "5.3.2"
   },
   "overrides": {
     "@dfinity/agent": "^0.19.3",

package/parallel.ts

@@ -1,4 +1,4 @@
-export async function parallel(threads: number, items: any[], fn: CallableFunction) {
+export async function parallel(threads : number, items : any[], fn : CallableFunction) {
 	return new Promise<void>((resolve) => {
 		let busyThreads = 0;
 		items = items.slice();

package/pem.ts

@@ -4,7 +4,7 @@ import {Secp256k1KeyIdentity} from '@dfinity/identity-secp256k1';
 import pemfile from 'pem-file';
 import crypto from 'crypto';
 
-export function decodeFile(file: string, password?: string) {
+export function decodeFile(file : string, password ?: string) {
 	let rawKey = fs.readFileSync(file);
 	if (password) {
 		return decode(decrypt(rawKey, password));
@@ -12,8 +12,8 @@ export function decodeFile(file: string, password?: string) {
 	return decode(rawKey);
 }
 
-function decode(rawKey: Buffer) {
-	let buf: Buffer = pemfile.decode(rawKey);
+function decode(rawKey : Buffer) {
+	let buf : Buffer = pemfile.decode(rawKey);
 	if (rawKey.includes('EC PRIVATE KEY')) {
 		if (buf.length != 118) {
 			throw 'expecting byte length 118 but got ' + buf.length;
@@ -29,7 +29,7 @@ function decode(rawKey: Buffer) {
 
 let algorithm = 'aes-256-ctr';
 
-export function encrypt(buffer: Buffer, password: string) {
+export function encrypt(buffer : Buffer, password : string) {
 	let key = crypto.createHash('sha256').update(password).digest('base64').slice(0, 32);
 	// Create an initialization vector
 	let iv = crypto.randomBytes(16);
@@ -40,7 +40,7 @@ export function encrypt(buffer: Buffer, password: string) {
 	return result;
 }
 
-function decrypt(encrypted: Buffer, password: string) {
+function decrypt(encrypted : Buffer, password : string) {
 	let key = crypto.createHash('sha256').update(password).digest('base64').slice(0, 32);
 	// Get the iv: the first 16 bytes
 	let iv = encrypted.subarray(0, 16);

package/release-cli.ts

@@ -0,0 +1,62 @@
+/* eslint-disable no-undef */
+import fs from 'node:fs';
+import path from 'node:path';
+import {URL} from 'node:url';
+import {execSync} from 'node:child_process';
+import semver from 'semver';
+import {sha256} from '@noble/hashes/sha256';
+import {bytesToHex} from '@noble/hashes/utils';
+
+import {findChangelogEntry} from './helpers/find-changelog-entry.js';
+
+let __dirname = new URL('.', import.meta.url).pathname;
+
+execSync('npm run prepare', {stdio: 'inherit', cwd: __dirname});
+execSync('npm run bundle', {stdio: 'inherit', cwd: __dirname});
+
+let version = JSON.parse(fs.readFileSync(path.resolve(__dirname, 'package.json'), 'utf8')).version;
+let major = semver.parse(version)?.major;
+let tag = semver.parse(version)?.prerelease[0] || 'latest';
+let releaseNotes = findChangelogEntry(fs.readFileSync(path.resolve(__dirname, 'CHANGELOG.md'), 'utf8'), version);
+let data = fs.readFileSync(path.resolve(__dirname, 'bundle/cli.tgz'));
+let hash = bytesToHex(sha256(data));
+let size = data.byteLength;
+
+fs.cpSync(path.resolve(__dirname, 'bundle/cli.tgz'), path.resolve(__dirname, `../cli-releases/versions/${version}.tgz`), {force: false, errorOnExist: true});
+
+fs.cpSync(path.resolve(__dirname, `../cli-releases/versions/${version}.tgz`), path.resolve(__dirname, `../cli-releases/versions/${tag}.tgz`), {force: true, errorOnExist: false, recursive: true});
+fs.cpSync(path.resolve(__dirname, `../cli-releases/versions/${version}.tgz`), path.resolve(__dirname, `../cli-releases/versions/${major}.tgz`), {force: true, errorOnExist: false, recursive: true});
+
+fs.writeFileSync(path.resolve(__dirname, `../cli-releases/tags/${tag}`), version);
+
+console.log(`Release '${version}' created with tag '${tag}'`);
+
+
+// releases.json
+type Releases = {
+	tags : Record<string, string>;
+	versions : Record<string, {
+		time : number;
+		size : number;
+		hash : string;
+		url : string;
+		relseaseNotes : string;
+	}>;
+};
+
+if (!fs.existsSync(path.resolve(__dirname, '../cli-releases/releases.json'))) {
+	fs.writeFileSync(path.resolve(__dirname, '../cli-releases/releases.json'), JSON.stringify({tags: {}, versions: {}}, null, 2));
+}
+
+let releases : Releases = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../cli-releases/releases.json'), 'utf8'));
+
+releases.tags[tag] = version;
+releases.versions[version] = {
+	time: new Date().getTime(),
+	size,
+	relseaseNotes: releaseNotes,
+	url: `https://cli.mops.one/versions/${version}.tgz`,
+	hash,
+};
+
+fs.writeFileSync(path.resolve(__dirname, '../cli-releases/releases.json'), JSON.stringify(releases, null, 2));

package/remove-scripts.ts

@@ -0,0 +1,6 @@
+import {readFileSync, writeFileSync} from 'node:fs';
+
+let text = readFileSync('dist/package.json', 'utf8');
+let json = JSON.parse(text);
+delete json.scripts;
+writeFileSync('dist/package.json', JSON.stringify(json, null, 2));

package/resolve-packages.ts

@@ -4,18 +4,18 @@ import {checkConfigFile, formatDir, formatGithubDir, getRootDir, parseGithubURL,
 import {VesselConfig, readVesselConfig} from './vessel.js';
 import {Config, Dependency} from './types.js';
 
-export async function resolvePackages({verbose = false} = {}): Promise<Record<string, string>> {
+export async function resolvePackages({verbose = false} = {}) : Promise<Record<string, string>> {
 	if (!checkConfigFile()) {
 		return {};
 	}
 
 	let rootDir = getRootDir();
-	let packages: Record<string, Dependency & {isRoot: boolean;}> = {};
-	let versions: Record<string, string[]> = {};
+	let packages : Record<string, Dependency & {isRoot : boolean;}> = {};
+	let versions : Record<string, string[]> = {};
 
-	let compareVersions = (a: string = '0.0.0', b: string = '0.0.0') => {
-		let ap = a.split('.').map((x: string) => parseInt(x)) as [number, number, number];
-		let bp = b.split('.').map((x: string) => parseInt(x)) as [number, number, number];
+	let compareVersions = (a : string = '0.0.0', b : string = '0.0.0') => {
+		let ap = a.split('.').map((x : string) => parseInt(x)) as [number, number, number];
+		let bp = b.split('.').map((x : string) => parseInt(x)) as [number, number, number];
 		if (ap[0] - bp[0]) {
 			return Math.sign(ap[0] - bp[0]);
 		}
@@ -30,7 +30,7 @@ export async function resolvePackages({verbose = false} = {}): Promise<Record<st
 
 	const gitVerRegex = new RegExp(/v(\d{1,2}\.\d{1,2}\.\d{1,2})(-.*)?$/);
 
-	const compareGitVersions = (repoA: string, repoB: string) => {
+	const compareGitVersions = (repoA : string, repoB : string) => {
 		const {branch: a} = parseGithubURL(repoA);
 		const {branch: b} = parseGithubURL(repoB);
 
@@ -45,7 +45,7 @@ export async function resolvePackages({verbose = false} = {}): Promise<Record<st
 		}
 	};
 
-	let collectDeps = async (config: Config | VesselConfig, configDir: string, isRoot = false) => {
+	let collectDeps = async (config : Config | VesselConfig, configDir : string, isRoot = false) => {
 		let allDeps = [...Object.values(config.dependencies || {})];
 		if (isRoot) {
 			allDeps = [...allDeps, ...Object.values(config['dev-dependencies'] || {})];
@@ -124,7 +124,7 @@ export async function resolvePackages({verbose = false} = {}): Promise<Record<st
 
 	return Object.fromEntries(
 		Object.entries(packages).map(([name, pkg]) => {
-			let version: string;
+			let version : string;
 			if (pkg.path) {
 				version = path.resolve(rootDir, pkg.path).replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
 			}

package/templates.ts

@@ -0,0 +1,5 @@
+import fs from 'node:fs';
+
+export function copyTemplateFileSync(file : string, dest : string) {
+	fs.copyFileSync(new URL(`./templates/${file}`, import.meta.url), dest);
+}

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
 	"extends": ["@tsconfig/strictest/tsconfig.json"],
 	"include": ["**/*.ts", "**/*.js"],
-	"exclude": ["node_modules", "dist", "dist.js", "declarations/**/*.js"],
+	"exclude": ["node_modules", "dist", "bundle", "dist.js", "declarations/**/*.js"],
 	"compilerOptions": {
 		"types": ["node"],
 		"target": "ES2021",

package/types.ts

@@ -1,38 +1,38 @@
 export type Config = {
-	package?: {
-		name: string;
-		version: string;
-		description?: string;
-		license?: string;
-		repository?: string;
-		keywords?: string[];
-		baseDir?: string;
-		readme?: string;
-		files?: string[];
-		homepage?: string;
-		documentation?: string;
-		dfx?: string;
-		moc?: string;
-		donation?: string;
+	package ?: {
+		name : string;
+		version : string;
+		description ?: string;
+		license ?: string;
+		repository ?: string;
+		keywords ?: string[];
+		baseDir ?: string;
+		readme ?: string;
+		files ?: string[];
+		homepage ?: string;
+		documentation ?: string;
+		dfx ?: string;
+		moc ?: string;
+		donation ?: string;
 	};
-	dependencies?: Dependencies;
-	'dev-dependencies'?: Dependencies;
-	toolchain?: Toolchain;
+	dependencies ?: Dependencies;
+	'dev-dependencies' ?: Dependencies;
+	toolchain ?: Toolchain;
 };
 
 export type Dependencies = Record<string, Dependency>;
 
 export type Dependency = {
-	name: string;
-	version?: string; // mops package
-	repo?: string; // github package
-	path?: string; // local package
+	name : string;
+	version ?: string; // mops package
+	repo ?: string; // github package
+	path ?: string; // local package
 }
 
 export type Toolchain = {
-	moc?: string;
-	wasmtime?: string;
-	'pocket-ic'?: string;
+	moc ?: string;
+	wasmtime ?: string;
+	'pocket-ic' ?: string;
 };
 
 export type Tool = 'moc' | 'wasmtime' | 'pocket-ic';

package/vessel.ts

@@ -10,14 +10,14 @@ import {pipeline} from 'stream';
 import {formatGithubDir, parseGithubURL, progressBar} from './mops.js';
 import {addCache, copyCache, isCached} from './cache.js';
 
-const dhallFileToJson = async (filePath: string, silent: boolean) => {
+const dhallFileToJson = async (filePath : string, silent : boolean) => {
 	if (existsSync(filePath)) {
 		let cwd = new URL(path.dirname(import.meta.url)).pathname;
 		let res;
 		try {
 			res = await execaCommand(`dhall-to-json --file ${filePath}`, {preferLocal:true, cwd});
 		}
-		catch (err: any) {
+		catch (err : any) {
 			silent || console.error('dhall-to-json error:', err.message?.split('Message:')[0]);
 			return null;
 		}
@@ -34,18 +34,18 @@ const dhallFileToJson = async (filePath: string, silent: boolean) => {
 };
 
 export type VesselConfig = {
-	dependencies: VesselDependencies;
-	'dev-dependencies': VesselDependencies;
+	dependencies : VesselDependencies;
+	'dev-dependencies' : VesselDependencies;
 };
 
 export type VesselDependencies = Array<{
-	name: string;
-	version?: string; // mops package
-	repo?: string; // github package
-	path?: string; // local package
+	name : string;
+	version ?: string; // mops package
+	repo ?: string; // github package
+	path ?: string; // local package
 }>;
 
-export const readVesselConfig = async (dir: string, {cache = true, silent = false} = {}): Promise<VesselConfig | null> => {
+export const readVesselConfig = async (dir : string, {cache = true, silent = false} = {}) : Promise<VesselConfig | null> => {
 	const cachedFile = (dir || process.cwd()) + '/vessel.json';
 
 	if (existsSync(cachedFile)) {
@@ -55,21 +55,21 @@ export const readVesselConfig = async (dir: string, {cache = true, silent = fals
 
 	const [vessel, packageSetArray] = await Promise.all([
 		dhallFileToJson((dir || process.cwd()) + '/vessel.dhall', silent),
-		dhallFileToJson((dir || process.cwd()) + '/package-set.dhall', silent)
+		dhallFileToJson((dir || process.cwd()) + '/package-set.dhall', silent),
 	]);
 
 	if (!vessel || !packageSetArray) {
 		return null;
 	}
 
-	let repos: Record<string, string> = {};
+	let repos : Record<string, string> = {};
 	for (const {name, repo, version} of packageSetArray) {
 		const {org, gitName} = parseGithubURL(repo);
 		repos[name] = `https://github.com/${org}/${gitName}#${version}`;
 	}
 
-	let config: VesselConfig = {
-		dependencies: vessel.dependencies.map((name: string) => {
+	let config : VesselConfig = {
+		dependencies: vessel.dependencies.map((name : string) => {
 			return {name, repo: repos[name], version: ''};
 		}),
 		'dev-dependencies': [],
@@ -82,7 +82,7 @@ export const readVesselConfig = async (dir: string, {cache = true, silent = fals
 	return config;
 };
 
-export const downloadFromGithub = async (repo: string, dest: string, onProgress: any) => {
+export const downloadFromGithub = async (repo : string, dest : string, onProgress : any) => {
 	const {branch, org, gitName, commitHash} = parseGithubURL(repo);
 
 	const zipFile = `https://github.com/${org}/${gitName}/archive/${commitHash || branch}.zip`;
@@ -148,7 +148,7 @@ export const downloadFromGithub = async (repo: string, dest: string, onProgress:
 	return promise;
 };
 
-export const installFromGithub = async (name: string, repo: string, {verbose = false, dep = false, silent = false} = {}) => {
+export const installFromGithub = async (name : string, repo : string, {verbose = false, dep = false, silent = false} = {}) => {
 	let {branch, commitHash} = parseGithubURL(repo);
 	let dir = formatGithubDir(name, repo);
 	let cacheName = `_github/${name}#${branch}` + (commitHash ? `@${commitHash}` : '');
@@ -165,7 +165,7 @@ export const installFromGithub = async (name: string, repo: string, {verbose = f
 	else {
 		mkdirSync(dir, {recursive: true});
 
-		let progress = (step: number, total: number) => {
+		let progress = (step : number, total : number) => {
 			silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} ${progressBar(step, total)}`);
 		};
 

package/commands/self-update.ts

@@ -1,6 +0,0 @@
-import child_process from 'node:child_process';
-
-export function selfUpdate({detached = false} = {}) {
-	console.log('Updating mops CLI...');
-	child_process.spawn('npm', ['install', 'ic-mops', '-g'], {stdio: 'inherit', detached});
-}

package/dist/commands/replica.d.ts

@@ -1,36 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import { ChildProcess, ChildProcessWithoutNullStreams } from 'node:child_process';
-import { PocketIc } from 'pic-ic';
-export declare class Replica {
-    type: 'dfx' | 'pocket-ic';
-    cwd: string;
-    verbose: boolean;
-    canisters: Record<string, {
-        cwd: string;
-        canisterId: string;
-        actor: any;
-    }>;
-    pocketIc?: PocketIc;
-    process?: ChildProcess;
-    constructor(type: 'dfx' | 'pocket-ic', cwd: string, verbose?: boolean);
-    start(): Promise<ChildProcessWithoutNullStreams>;
-    stop(): Promise<void>;
-    deploy(name: string, wasm: string, cwd?: string): Promise<void>;
-    getActor(name: string): unknown;
-    getCanisterId(name: string): string;
-    dfxJson(canisterName: string): {
-        version: number;
-        canisters: Record<string, any>;
-        defaults: {
-            build: {
-                packtool: string;
-            };
-        };
-        networks: {
-            local: {
-                type: string;
-                bind: string;
-            };
-        };
-    };
-}