ic-mops 0.39.2 → 0.41.0

package/commands/toolchain/pocket-ic.ts

@@ -9,37 +9,19 @@ let cacheDir = path.join(globalCacheDir, 'pocket-ic');
 export let repo = 'dfinity/pocketic';
 
 export let getLatestReleaseTag = async () => {
-	return '1.0.0';
-	// return toolchainUtils.getLatestReleaseTag(repo);
+	return toolchainUtils.getLatestReleaseTag(repo);
 };
 
 export let getReleases = async () => {
-	// return toolchainUtils.getReleases(repo);
-	return [
-		{
-			tag_name: '2.0.1',
-			published_at: new Date('2023-11-23'),
-			draft: false,
-		},
-		{
-			tag_name: '2.0.0',
-			published_at: new Date('2023-11-21'),
-			draft: false,
-		},
-		{
-			tag_name: '1.0.0',
-			published_at: new Date('2023-10-12'),
-			draft: false,
-		},
-	];
+	return toolchainUtils.getReleases(repo);
 };
 
-export let isCached = (version: string) => {
+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} = {}) => {
+export let download = async (version : string, {silent = false, verbose = false} = {}) => {
 	if (!version) {
 		console.error('version is not defined');
 		process.exit(1);
@@ -53,18 +35,11 @@ export let download = async (version: string, {silent = false, verbose = false}
 
 	let platfrom = process.platform == 'darwin' ? 'darwin' : 'linux';
 	let arch = 'x86_64';
-
-	let hashes: Record<string, string> = {
-		'2.0.1': '69e1408347723dbaa7a6cd2faa9b65c42abbe861',
-		'2.0.0': '29ec86dc9f9ca4691d4d4386c8b2aa41e14d9d16',
-		'1.0.0': '307d5847c1d2fe1f5e19181c7d0fcec23f4658b3',
-	};
-
-	let url = `https://download.dfinity.systems/ic/${hashes[version]}/openssl-static-binaries/${arch}-${platfrom}/pocket-ic.gz`;
+	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));
+	await toolchainUtils.downloadAndExtract(url, path.join(cacheDir, version), 'pocket-ic');
 };

package/commands/toolchain/toolchain-utils.ts

@@ -10,7 +10,7 @@ import tar from 'tar';
 
 import {getRootDir} from '../../mops.js';
 
-export let downloadAndExtract = async (url: string, dest: string) => {
+export let downloadAndExtract = async (url : string, destDir : string, destFileName : string = '') => {
 	let res = await fetch(url);
 
 	if (res.status !== 200) {
@@ -27,7 +27,7 @@ export let downloadAndExtract = async (url: string, dest: string) => {
 	fs.mkdirSync(tmpDir, {recursive: true});
 	fs.writeFileSync(archive, buffer);
 
-	fs.mkdirSync(dest, {recursive: true});
+	fs.mkdirSync(destDir, {recursive: true});
 
 	if (archive.endsWith('.xz')) {
 		let decompressTarxz = await import('decomp-tarxz');
@@ -36,16 +36,16 @@ export let downloadAndExtract = async (url: string, dest: string) => {
 		}).catch(() => {
 			deleteSync([tmpDir]);
 		});
-		fs.cpSync(path.join(tmpDir, path.parse(archive).name.replace('.tar', '')), dest, {recursive: true});
+		fs.cpSync(path.join(tmpDir, path.parse(archive).name.replace('.tar', '')), destDir, {recursive: true});
 	}
 	else if (archive.endsWith('tar.gz')) {
 		await tar.extract({
 			file: archive,
-			cwd: dest,
+			cwd: destDir,
 		});
 	}
 	else if (archive.endsWith('.gz')) {
-		let destFile = path.join(dest, path.parse(archive).name);
+		let destFile = path.join(destDir, destFileName || path.parse(archive).name);
 		fs.writeFileSync(destFile, unzipSync(buffer));
 		chmodSync(destFile, 0o700);
 	}
@@ -53,9 +53,9 @@ export let downloadAndExtract = async (url: string, dest: string) => {
 	deleteSync([tmpDir], {force: true});
 };
 
-export let getLatestReleaseTag = async (repo: string): Promise<string> => {
+export let getLatestReleaseTag = async (repo : string) : Promise<string> => {
 	let releases = await getReleases(repo);
-	let release = releases.find((release: any) => !release.prerelease && !release.draft);
+	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);
@@ -63,19 +63,19 @@ export let getLatestReleaseTag = async (repo: string): Promise<string> => {
 	return release.tag_name.replace(/^v/, '');
 };
 
-export let getReleases = async (repo: string) => {
+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'
-		}
+			'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 res.data.map((release : any) => {
 		return {
 			...release,
 			tag_name: release.tag_name.replace(/^v/, ''),

package/commands/toolchain/wasmtime.ts

@@ -16,12 +16,12 @@ export let getReleases = async () => {
 	return toolchainUtils.getReleases(repo);
 };
 
-export let isCached = (version: string) => {
+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} = {}) => {
+export let download = async (version : string, {silent = false, verbose = false} = {}) => {
 	if (!version) {
 		console.error('version is not defined');
 		process.exit(1);

package/commands/transfer-ownership.ts

@@ -4,7 +4,7 @@ import {mainActor} from '../api/actors.js';
 import {Principal} from '@dfinity/principal';
 import prompts from 'prompts';
 
-export async function transferOwnership(toPrincipal: string) {
+export async function transferOwnership(toPrincipal : string) {
 	if (!checkConfigFile()) {
 		return;
 	}
@@ -16,7 +16,7 @@ export async function transferOwnership(toPrincipal: string) {
 		onCancel() {
 			console.log('aborted');
 			process.exit(0);
-		}
+		},
 	};
 
 	console.log(chalk.red('Warning: ') + 'This action cannot be undone!');

package/commands/update.ts

@@ -5,12 +5,12 @@ import {getAvailableUpdates} from './available-updates.js';
 import {checkIntegrity} from '../integrity.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 = {}) {
+export async function update(pkg ?: string, {lock} : UpdateOptions = {}) {
 	if (!checkConfigFile()) {
 		return;
 	}

package/commands/user.ts

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import {getIdentity} from '../mops.js';
 import {mainActor} from '../api/actors.js';
 
-export async function getUserProp(prop: string) {
+export async function getUserProp(prop : string) {
 	let actor = await mainActor();
 	let identity = await getIdentity();
 	if (!identity) {
@@ -14,7 +14,7 @@ export async function getUserProp(prop: string) {
 	console.log(res[0]?.[prop] || '');
 }
 
-export async function setUserProp(prop: string, value: string) {
+export async function setUserProp(prop : string, value : string) {
 	let identity = await getIdentity();
 	let actor = await mainActor(identity);
 

package/declarations/bench/bench.did.d.ts

@@ -1,5 +1,6 @@
 import type { Principal } from '@dfinity/principal';
 import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
 
 export interface BenchResult {
   'instructions' : bigint,
@@ -24,3 +25,5 @@ export interface anon_class_10_1 {
   'runCellUpdateAwait' : ActorMethod<[bigint, bigint], BenchResult>,
 }
 export interface _SERVICE extends anon_class_10_1 {}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: ({ IDL }: { IDL: IDL }) => IDL.Type[];

package/declarations/main/main.did

@@ -216,6 +216,7 @@ type PackageFileStatsPublic =
  };
 type PackageDetails = 
  record {
+   benchmarks: Benchmarks__1;
    changes: PackageChanges;
    config: PackageConfigV2__1;
    dependents: vec PackageSummary__1;
@@ -273,9 +274,11 @@ type PackageConfigV2 =
  };
 type PackageChanges = 
  record {
+   curBenchmarks: Benchmarks__1;
    deps: vec DepChange;
    devDeps: vec DepChange;
    notes: text;
+   prevBenchmarks: Benchmarks__1;
    tests: TestsChanges;
  };
 type Main = 
@@ -303,6 +306,7 @@ type Main =
                  blob;
                };
          });
+   getFileHashesQuery: (PackageName, PackageVersion) -> (Result_8) query;
    getFileIds: (PackageName, PackageVersion) -> (Result_7) query;
    getHighestSemverBatch:
     (vec record {
@@ -333,13 +337,14 @@ type Main =
                           PackageName;
                           PackageVersion;
                         }) -> () oneway;
-   restore: (nat, nat) -> ();
+   restore: (nat) -> ();
    search: (Text, opt nat, opt nat) -> (vec PackageSummary, PageCount) query;
    setUserProp: (text, text) -> (Result_1);
    startFileUpload: (PublishingId, Text, nat, blob) -> (Result_3);
    startPublish: (PackageConfigV2) -> (Result_2);
    transferOwnership: (PackageName, principal) -> (Result_1);
    transformRequest: (HttpTransformArg) -> (HttpResponse) query;
+   uploadBenchmarks: (PublishingId, Benchmarks) -> (Result);
    uploadFileChunk: (PublishingId, FileId, nat, blob) -> (Result);
    uploadNotes: (PublishingId, text) -> (Result);
    uploadTestStats: (PublishingId, TestStats) -> (Result);
@@ -397,4 +402,25 @@ type DepChange =
    newVersion: text;
    oldVersion: text;
  };
+type Benchmarks__1 = vec Benchmark;
+type Benchmarks = vec Benchmark;
+type BenchmarkMetric = text;
+type Benchmark = 
+ record {
+   cols: vec text;
+   compiler: text;
+   compilerVersion: text;
+   description: text;
+   file: text;
+   forceGC: bool;
+   gc: text;
+   metrics: vec record {
+                  BenchmarkMetric;
+                  vec vec int;
+                };
+   name: text;
+   replica: text;
+   replicaVersion: text;
+   rows: vec text;
+ };
 service : () -> Main

package/declarations/main/main.did.d.ts

@@ -1,6 +1,24 @@
 import type { Principal } from '@dfinity/principal';
 import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
 
+export interface Benchmark {
+  'gc' : string,
+  'metrics' : Array<[BenchmarkMetric, Array<Array<bigint>>]>,
+  'cols' : Array<string>,
+  'file' : string,
+  'name' : string,
+  'rows' : Array<string>,
+  'description' : string,
+  'compilerVersion' : string,
+  'compiler' : string,
+  'replica' : string,
+  'replicaVersion' : string,
+  'forceGC' : boolean,
+}
+export type BenchmarkMetric = string;
+export type Benchmarks = Array<Benchmark>;
+export type Benchmarks__1 = Array<Benchmark>;
 export interface DepChange {
   'oldVersion' : string,
   'name' : string,
@@ -60,6 +78,7 @@ export interface Main {
     [Array<PackageId>],
     Array<[PackageId, Array<[FileId, Uint8Array | number[]]>]>
   >,
+  'getFileHashesQuery' : ActorMethod<[PackageName, PackageVersion], Result_8>,
   'getFileIds' : ActorMethod<[PackageName, PackageVersion], Result_7>,
   'getHighestSemverBatch' : ActorMethod<
     [Array<[PackageName, PackageVersion, SemverPart]>],
@@ -88,7 +107,7 @@ export interface Main {
     [Array<[PackageName, PackageVersion]>],
     undefined
   >,
-  'restore' : ActorMethod<[bigint, bigint], undefined>,
+  'restore' : ActorMethod<[bigint], undefined>,
   'search' : ActorMethod<
     [Text, [] | [bigint], [] | [bigint]],
     [Array<PackageSummary>, PageCount]
@@ -101,6 +120,7 @@ export interface Main {
   'startPublish' : ActorMethod<[PackageConfigV2], Result_2>,
   'transferOwnership' : ActorMethod<[PackageName, Principal], Result_1>,
   'transformRequest' : ActorMethod<[HttpTransformArg], HttpResponse>,
+  'uploadBenchmarks' : ActorMethod<[PublishingId, Benchmarks], Result>,
   'uploadFileChunk' : ActorMethod<
     [PublishingId, FileId, bigint, Uint8Array | number[]],
     Result
@@ -111,6 +131,8 @@ export interface Main {
 export interface PackageChanges {
   'tests' : TestsChanges,
   'deps' : Array<DepChange>,
+  'curBenchmarks' : Benchmarks__1,
+  'prevBenchmarks' : Benchmarks__1,
   'notes' : string,
   'devDeps' : Array<DepChange>,
 }
@@ -151,6 +173,7 @@ export interface PackageConfigV2__1 {
   'readme' : string,
 }
 export interface PackageDetails {
+  'benchmarks' : Benchmarks__1,
   'ownerInfo' : User,
   'owner' : Principal,
   'deps' : Array<PackageSummary__1>,
@@ -325,3 +348,5 @@ export interface User__1 {
   'github' : string,
 }
 export interface _SERVICE extends Main {}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: ({ IDL }: { IDL: IDL }) => IDL.Type[];

package/declarations/main/main.did.js

@@ -95,6 +95,22 @@ export const idlFactory = ({ IDL }) => {
     'config' : PackageConfigV2__1,
     'publication' : PackagePublication,
   });
+  const BenchmarkMetric = IDL.Text;
+  const Benchmark = IDL.Record({
+    'gc' : IDL.Text,
+    'metrics' : IDL.Vec(IDL.Tuple(BenchmarkMetric, IDL.Vec(IDL.Vec(IDL.Int)))),
+    'cols' : IDL.Vec(IDL.Text),
+    'file' : IDL.Text,
+    'name' : IDL.Text,
+    'rows' : IDL.Vec(IDL.Text),
+    'description' : IDL.Text,
+    'compilerVersion' : IDL.Text,
+    'compiler' : IDL.Text,
+    'replica' : IDL.Text,
+    'replicaVersion' : IDL.Text,
+    'forceGC' : IDL.Bool,
+  });
+  const Benchmarks__1 = IDL.Vec(Benchmark);
   const PackageSummary__1 = IDL.Record({
     'ownerInfo' : User,
     'owner' : IDL.Principal,
@@ -130,6 +146,8 @@ export const idlFactory = ({ IDL }) => {
   const PackageChanges = IDL.Record({
     'tests' : TestsChanges,
     'deps' : IDL.Vec(DepChange),
+    'curBenchmarks' : Benchmarks__1,
+    'prevBenchmarks' : Benchmarks__1,
     'notes' : IDL.Text,
     'devDeps' : IDL.Vec(DepChange),
   });
@@ -145,6 +163,7 @@ export const idlFactory = ({ IDL }) => {
     'publication' : PackagePublication,
   });
   const PackageDetails = IDL.Record({
+    'benchmarks' : Benchmarks__1,
     'ownerInfo' : User,
     'owner' : IDL.Principal,
     'deps' : IDL.Vec(PackageSummary__1),
@@ -255,6 +274,7 @@ export const idlFactory = ({ IDL }) => {
     'context' : IDL.Vec(IDL.Nat8),
     'response' : HttpResponse,
   });
+  const Benchmarks = IDL.Vec(Benchmark);
   const TestStats = IDL.Record({
     'passedNames' : IDL.Vec(IDL.Text),
     'passed' : IDL.Nat,
@@ -290,6 +310,11 @@ export const idlFactory = ({ IDL }) => {
         ],
         [],
       ),
+    'getFileHashesQuery' : IDL.Func(
+        [PackageName, PackageVersion],
+        [Result_8],
+        ['query'],
+      ),
     'getFileIds' : IDL.Func(
         [PackageName, PackageVersion],
         [Result_7],
@@ -342,7 +367,7 @@ export const idlFactory = ({ IDL }) => {
         [],
         ['oneway'],
       ),
-    'restore' : IDL.Func([IDL.Nat, IDL.Nat], [], []),
+    'restore' : IDL.Func([IDL.Nat], [], []),
     'search' : IDL.Func(
         [Text, IDL.Opt(IDL.Nat), IDL.Opt(IDL.Nat)],
         [IDL.Vec(PackageSummary), PageCount],
@@ -365,6 +390,7 @@ export const idlFactory = ({ IDL }) => {
         [HttpResponse],
         ['query'],
       ),
+    'uploadBenchmarks' : IDL.Func([PublishingId, Benchmarks], [Result], []),
     'uploadFileChunk' : IDL.Func(
         [PublishingId, FileId, IDL.Nat, IDL.Vec(IDL.Nat8)],
         [Result],

package/dist/api/downloadPackageFiles.d.ts

@@ -6,7 +6,7 @@ export declare function getPackageFilesInfo(pkg: string, version: string): Promi
     fileIds: string[];
 }>;
 export declare function getFileIds(pkg: string, version: string): Promise<string[]>;
-export declare function downloadFile(storage: Storage, fileId: string): Promise<{
+export declare function downloadFile(storage: Storage | string, fileId: string): Promise<{
     path: string;
     data: Array<number>;
 }>;

package/dist/api/downloadPackageFiles.js

@@ -1,3 +1,4 @@
+import { Principal } from '@dfinity/principal';
 import { mainActor, storageActor } from './actors.js';
 import { resolveVersion } from './resolveVersion.js';
 import { parallel } from '../parallel.js';
@@ -41,6 +42,9 @@ export async function getFileIds(pkg, version) {
 }
 // download single file
 export async function downloadFile(storage, fileId) {
+    if (typeof storage === 'string') {
+        storage = await storageActor(Principal.fromText(storage));
+    }
     let fileMetaRes = await storage.getFileMeta(fileId);
     if ('err' in fileMetaRes) {
         throw fileMetaRes.err;

package/dist/bin/moc-wrapper.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+mocPath="$(mops toolchain bin moc --fallback)"
+$mocPath "$@"

package/dist/bin/mops.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import '../cli.js';
+export {};

package/dist/bin/mops.js

@@ -1,2 +1,3 @@
 #!/usr/bin/env node
-import '../cli.js';
+
+import '../cli.js';

package/dist/bundle-package-json.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bundle-package-json.js

@@ -0,0 +1,11 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+let packageJson = JSON.parse(readFileSync('./bundle/package.json', 'utf8'));
+delete packageJson.scripts;
+delete packageJson.devDependencies;
+delete packageJson.overrides;
+packageJson.dependencies = {
+    'dhall-to-json-cli': packageJson.dependencies['dhall-to-json-cli'],
+    'decomp-tarxz': packageJson.dependencies['decomp-tarxz'],
+    'buffer': packageJson.dependencies['buffer'],
+};
+writeFileSync('./bundle/package.json', JSON.stringify(packageJson, null, '  '));

package/dist/check-requirements.d.ts

@@ -0,0 +1,3 @@
+export declare function checkRequirements({ verbose }?: {
+    verbose?: boolean | undefined;
+}): Promise<void>;

package/dist/check-requirements.js

@@ -0,0 +1,39 @@
+import path from 'node:path';
+import { getDependencyType, readConfig } from './mops.js';
+import { resolvePackages } from './resolve-packages.js';
+import { SemVer } from 'semver';
+import chalk from 'chalk';
+export async function checkRequirements({ verbose = false } = {}) {
+    let config = readConfig();
+    if (!config.toolchain?.moc) {
+        return;
+    }
+    let installedMoc = new SemVer(config.toolchain.moc);
+    let highestRequiredMoc = new SemVer('0.0.0');
+    let highestRequiredMocPkgId = '';
+    let resolvedPackages = await resolvePackages();
+    for (let [name, version] of Object.entries(resolvedPackages)) {
+        if (getDependencyType(version) === 'mops') {
+            let pkgId = `${name}@${version}`;
+            let depConfig = readConfig(path.join('.mops', pkgId, 'mops.toml'));
+            let moc = depConfig.requirements?.moc;
+            if (moc) {
+                let requiredMoc = new SemVer(moc);
+                if (highestRequiredMoc.compare(requiredMoc) < 0) {
+                    highestRequiredMoc = requiredMoc;
+                    highestRequiredMocPkgId = pkgId;
+                }
+                verbose && _check(pkgId, installedMoc, requiredMoc);
+            }
+        }
+    }
+    verbose || _check(highestRequiredMocPkgId, installedMoc, highestRequiredMoc);
+}
+function _check(pkgId, installedMoc, requiredMoc) {
+    let comp = installedMoc.compare(requiredMoc);
+    if (comp < 0) {
+        console.log(chalk.yellow(`moc version does not meet the requirements of ${pkgId}`));
+        console.log(chalk.yellow(`  Required: >= ${requiredMoc.format()}`));
+        console.log(chalk.yellow(`  Installed:   ${installedMoc.format()}`));
+    }
+}

package/dist/cli.js

@@ -5,7 +5,7 @@ import { init } from './commands/init.js';
 import { publish } from './commands/publish.js';
 import { importPem } from './commands/import-identity.js';
 import { sources } from './commands/sources.js';
-import { checkApiCompatibility, setNetwork, apiVersion, checkConfigFile, getNetworkFile } from './mops.js';
+import { checkApiCompatibility, setNetwork, apiVersion, checkConfigFile, getNetworkFile, version } from './mops.js';
 import { getNetwork } from './api/network.js';
 import { whoami } from './commands/whoami.js';
 import { installAll } from './commands/install-all.js';
@@ -14,7 +14,6 @@ import { add } from './commands/add.js';
 import { cacheSize, cleanCache } from './cache.js';
 import { test } from './commands/test/test.js';
 import { template } from './commands/template.js';
-import { selfUpdate } from './commands/self-update.js';
 import { remove } from './commands/remove.js';
 import { getUserProp, setUserProp } from './commands/user.js';
 import { bump } from './commands/bump.js';
@@ -24,6 +23,7 @@ import { update } from './commands/update.js';
 import { bench } from './commands/bench.js';
 import { transferOwnership } from './commands/transfer-ownership.js';
 import { toolchain } from './commands/toolchain/index.js';
+import * as self from './commands/self.js';
 let networkFile = getNetworkFile();
 if (fs.existsSync(networkFile)) {
     globalThis.MOPS_NETWORK = fs.readFileSync(networkFile).toString() || 'ic';
@@ -31,8 +31,7 @@ if (fs.existsSync(networkFile)) {
 let program = new Command();
 program.name('mops');
 // --version
-let packageJson = JSON.parse(fs.readFileSync(new URL('package.json', import.meta.url)).toString());
-program.version(`CLI ${packageJson.version}\nAPI ${apiVersion}`, '-v --version');
+program.version(`CLI ${version()}\nAPI ${apiVersion}`, '-v --version');
 // init
 program
     .command('init')
@@ -101,6 +100,7 @@ program
     .description('Publish package to the mops registry')
     .option('--no-docs', 'Do not generate docs')
     .option('--no-test', 'Do not run tests')
+    .option('--no-bench', 'Do not run benchmarks')
     .action(async (options) => {
     if (!checkConfigFile()) {
         process.exit(1);
@@ -224,20 +224,6 @@ program
 // 		}
 // 		await docs();
 // 	});
-// self update
-program
-    .command('self-update')
-    .description('Update mops CLI to the latest version')
-    .option('--detached')
-    .option('--force')
-    .action(async (options) => {
-    if (options.force) {
-        selfUpdate(options);
-    }
-    else {
-        console.log('Please run \'npm i -g ic-mops\'');
-    }
-});
 // user
 program
     .command('user')
@@ -339,4 +325,19 @@ toolchainCommand
     console.log(bin);
 });
 program.addCommand(toolchainCommand);
+// self
+const selfCommand = new Command('self').description('Mops CLI management');
+selfCommand
+    .command('update')
+    .description('Update mops CLI to the latest version')
+    .action(async () => {
+    await self.update();
+});
+selfCommand
+    .command('uninstall')
+    .description('Uninstall mops CLI')
+    .action(async () => {
+    await self.uninstall();
+});
+program.addCommand(selfCommand);
 program.parse();

package/dist/commands/bench-replica.d.ts

@@ -9,7 +9,9 @@ export declare class BenchReplica {
     }>;
     pocketIc?: PocketIc;
     constructor(type: 'dfx' | 'pocket-ic', verbose?: boolean);
-    start(): Promise<void>;
+    start({ silent }?: {
+        silent?: boolean | undefined;
+    }): Promise<void>;
     stop(): Promise<void>;
     deploy(name: string, wasm: string, cwd?: string): Promise<void>;
     getActor(name: string): unknown;

package/dist/commands/bench-replica.js

@@ -13,8 +13,8 @@ export class BenchReplica {
         this.type = type;
         this.verbose = verbose;
     }
-    async start() {
-        console.log(`Starting ${this.type} replica...`);
+    async start({ silent = false } = {}) {
+        silent || console.log(`Starting ${this.type} replica...`);
         if (this.type == 'dfx') {
             await this.stop();
             let dir = path.join(getRootDir(), '.mops/.bench');