ic-mops 0.45.3 → 1.0.0-pre.0

package/dist/cli.js

@@ -1,14 +1,11 @@
 import process from 'node:process';
 import fs from 'node:fs';
 import { Command, Argument, Option } from 'commander';
-import chalk from 'chalk';
 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, version } from './mops.js';
 import { getNetwork } from './api/network.js';
-import { whoami } from './commands/whoami.js';
 import { installAll } from './commands/install/install-all.js';
 import { search } from './commands/search.js';
 import { add } from './commands/add.js';
@@ -16,7 +13,7 @@ import { cacheSize, cleanCache, show } from './cache.js';
 import { test } from './commands/test/test.js';
 import { template } from './commands/template.js';
 import { remove } from './commands/remove.js';
-import { getUserProp, setUserProp } from './commands/user.js';
+import { importPem, getPrincipal, getUserProp, setUserProp } from './commands/user.js';
 import { bump } from './commands/bump.js';
 import { sync } from './commands/sync.js';
 import { outdated } from './commands/outdated.js';
@@ -25,6 +22,7 @@ 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';
+import { resolvePackages } from './resolve-packages.js';
 let networkFile = getNetworkFile();
 if (fs.existsSync(networkFile)) {
     globalThis.MOPS_NETWORK = fs.readFileSync(networkFile).toString() || 'ic';
@@ -71,12 +69,12 @@ program
 });
 // install
 program
-    .command('install [pkg]')
+    .command('install')
     .alias('i')
     .description('Install all dependencies specified in mops.toml')
     .option('--verbose')
     .addOption(new Option('--lock <action>', 'Lockfile action').choices(['check', 'update', 'ignore']))
-    .action(async (pkg, options) => {
+    .action(async (options) => {
     if (!checkConfigFile()) {
         process.exit(1);
     }
@@ -85,17 +83,12 @@ program
         return;
     }
     await toolchain.ensureToolchainInited({ strict: false });
-    if (pkg) {
-        // @deprecated
-        console.log(chalk.yellow('Consider using the \'mops add\' command to install a specific package.'));
-        await add(pkg, options);
-    }
-    else {
-        let ok = await installAll(options);
-        await toolchain.installAll(options);
-        if (!ok) {
-            process.exit(1);
-        }
+    let ok = await installAll(options);
+    await toolchain.installAll(options);
+    // check conflicts
+    await resolvePackages({ conflicts: 'warning' });
+    if (!ok) {
+        process.exit(1);
     }
 });
 // publish
@@ -132,21 +125,22 @@ program
     .action(async () => {
     console.log(getNetwork());
 });
-// import-identity
+// user import
 program
-    .command('import-identity <data>')
+    .command('mops user import <data>')
     .description('Import .pem file data to use as identity')
     .addOption(new Option('--no-encrypt', 'Do not ask for a password to encrypt identity'))
     .action(async (data, options) => {
     await importPem(data, options);
-    await whoami();
+    await getPrincipal();
 });
 // sources
 program
     .command('sources')
     .description('for dfx packtool')
     .option('--no-install', 'Do not install dependencies before running sources')
-    .option('--verbose')
+    .addOption(new Option('--conflicts <action>', 'What to do with dependency version conflicts').choices(['ignore', 'warning', 'error']).default('warning'))
+    .option('--verbose', 'Show more information') // for backcompat
     .action(async (options) => {
     if (!checkConfigFile()) {
         process.exit(1);
@@ -158,12 +152,12 @@ program
     let sourcesArr = await sources(options);
     console.log(sourcesArr.join('\n'));
 });
-// whoami
+// get-principal
 program
-    .command('whoami')
+    .command('get-principal')
     .description('Print your principal')
     .action(async () => {
-    await whoami();
+    await getPrincipal();
 });
 // search
 program
@@ -194,10 +188,12 @@ program
 program
     .command('test [filter]')
     .description('Run tests')
-    .addOption(new Option('-r, --reporter <reporter>', 'Test reporter').choices(['verbose', 'compact', 'files', 'silent']).default('verbose'))
-    .addOption(new Option('--mode <mode>', 'Test mode').choices(['interpreter', 'wasi']).default('interpreter'))
+    .addOption(new Option('-r, --reporter <reporter>', 'Test reporter').choices(['verbose', 'compact', 'files', 'silent']))
+    .addOption(new Option('--mode <mode>', 'Test mode').choices(['interpreter', 'wasi', 'replica']).default('interpreter'))
+    .addOption(new Option('--replica <replica>', 'Which replica to use to run tests in replica mode').choices(['dfx', 'pocket-ic']))
     .option('-w, --watch', 'Enable watch mode')
     .action(async (filter, options) => {
+    checkConfigFile(true);
     await installAll({ silent: true, lock: 'ignore' });
     await test(filter, options);
 });
@@ -205,13 +201,14 @@ program
 program
     .command('bench [filter]')
     .description('Run benchmarks')
-    .addOption(new Option('--replica <replica>', 'Which replica to use to run benchmarks').choices(['dfx', 'pocket-ic']).default('dfx'))
+    .addOption(new Option('--replica <replica>', 'Which replica to use to run benchmarks').choices(['dfx', 'pocket-ic']))
     .addOption(new Option('--gc <gc>', 'Garbage collector').choices(['copying', 'compacting', 'generational', 'incremental']).default('copying'))
     .addOption(new Option('--save', 'Save benchmark results to .bench/<filename>.json'))
     .addOption(new Option('--compare', 'Run benchmark and compare results with .bench/<filename>.json'))
     // .addOption(new Option('--force-gc', 'Force GC'))
     .addOption(new Option('--verbose', 'Show more information'))
     .action(async (filter, options) => {
+    checkConfigFile(true);
     await installAll({ silent: true, lock: 'ignore' });
     await bench(filter, options);
 });

package/dist/commands/add.js

@@ -10,6 +10,7 @@ import { checkIntegrity } from '../integrity.js';
 import { checkRequirements } from '../check-requirements.js';
 import { syncLocalCache } from './install/sync-local-cache.js';
 import { notifyInstalls } from '../notify-installs.js';
+import { resolvePackages } from '../resolve-packages.js';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function add(name, { verbose = false, dev = false, lock } = {}, asName) {
     if (!checkConfigFile()) {
@@ -104,4 +105,6 @@ export async function add(name, { verbose = false, dev = false, lock } = {}, asN
     logUpdate.clear();
     await checkRequirements({ verbose });
     console.log(chalk.green('Package installed ') + `${pkgDetails.name} = "${pkgDetails.repo || pkgDetails.path || pkgDetails.version}"`);
+    // check conflicts
+    await resolvePackages({ conflicts: 'warning' });
 }

package/dist/commands/bench/bench-canister.mo

@@ -2,17 +2,35 @@ import Nat64 "mo:base/Nat64";
 import Nat "mo:base/Nat";
 import Debug "mo:base/Debug";
 import ExperimentalInternetComputer "mo:base/ExperimentalInternetComputer";
+import ExperimentalStableMemory "mo:base/ExperimentalStableMemory";
+import Int64 "mo:base/Int64";
+import Region "mo:base/Region";
 import Prim "mo:prim";
 import Bench "mo:bench";
 
 import UserBench "./user-bench"; // file path will be replaced with the *.bench.mo file path
 
 actor class() {
+	type BenchResult = {
+		instructions : Int;
+		rts_mutator_instructions : Int;
+		stable_memory_size : Int;
+		rts_stable_memory_size : Int;
+		rts_logical_stable_memory_size : Int;
+		rts_collector_instructions : Int;
+		rts_heap_size : Int;
+		rts_memory_size : Int;
+		rts_total_allocation : Int;
+		rts_reclaimed : Int;
+	};
+
 	var benchOpt : ?Bench.Bench = null;
 
 	public func init() : async Bench.BenchSchema {
 		let bench = UserBench.init();
 		benchOpt := ?bench;
+		// ignore ExperimentalStableMemory.grow(1);
+		ignore Region.grow(Region.new(), 1);
 		bench.getSchema();
 	};
 
@@ -21,29 +39,37 @@ actor class() {
 		bench.getSchema();
 	};
 
-	func _getStats() : Bench.BenchResult {
+	func _getStats() : BenchResult {
 		{
 			instructions = 0;
 			rts_heap_size = Prim.rts_heap_size();
+			stable_memory_size = Int64.toInt(Int64.fromNat64(ExperimentalStableMemory.size())) * 65536;
+			rts_stable_memory_size = Prim.rts_stable_memory_size();
+			rts_logical_stable_memory_size = Prim.rts_logical_stable_memory_size();
 			rts_memory_size = Prim.rts_memory_size();
 			rts_total_allocation = Prim.rts_total_allocation();
+			rts_reclaimed = Prim.rts_reclaimed();
 			rts_mutator_instructions = Prim.rts_mutator_instructions();
 			rts_collector_instructions = Prim.rts_collector_instructions();
 		}
 	};
 
-	func _diffStats(before : Bench.BenchResult, after : Bench.BenchResult) : Bench.BenchResult {
+	func _diffStats(before : BenchResult, after : BenchResult) : BenchResult {
 		{
 			instructions = after.instructions - before.instructions;
 			rts_heap_size = after.rts_heap_size - before.rts_heap_size;
+			stable_memory_size = after.stable_memory_size - before.stable_memory_size;
+			rts_stable_memory_size = after.rts_stable_memory_size - before.rts_stable_memory_size;
+			rts_logical_stable_memory_size = after.rts_logical_stable_memory_size - before.rts_logical_stable_memory_size;
 			rts_memory_size = after.rts_memory_size - before.rts_memory_size;
 			rts_total_allocation = after.rts_total_allocation - before.rts_total_allocation;
+			rts_reclaimed = after.rts_reclaimed - before.rts_reclaimed;
 			rts_mutator_instructions = after.rts_mutator_instructions - before.rts_mutator_instructions;
 			rts_collector_instructions = after.rts_collector_instructions - before.rts_collector_instructions;
 		}
 	};
 
-	func _runCell(rowIndex : Nat, colIndex : Nat) : Bench.BenchResult {
+	func _runCell(rowIndex : Nat, colIndex : Nat) : BenchResult {
 		let ?bench = benchOpt else Debug.trap("bench not initialized");
 		let statsBefore = _getStats();
 
@@ -55,7 +81,7 @@ actor class() {
 		_diffStats(statsBefore, { statsAfter with instructions });
 	};
 
-	func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+	func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
 		let ?bench = benchOpt else Debug.trap("bench not initialized");
 		let statsBefore = _getStats();
 
@@ -69,19 +95,19 @@ actor class() {
 		_diffStats(statsBefore, { statsAfter with instructions });
 	};
 
-	public query func getStats() : async Bench.BenchResult {
+	public query func getStats() : async BenchResult {
 		_getStats();
 	};
 
-	public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+	public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async BenchResult {
 		_runCell(rowIndex, colIndex);
 	};
 
-	public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+	public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async BenchResult {
 		_runCell(rowIndex, colIndex);
 	};
 
-	public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+	public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async BenchResult {
 		await _runCellAwait(rowIndex, colIndex);
 	};
 };

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

@@ -1,4 +1,4 @@
-import { PocketIc } from 'pic-ic';
+import { PocketIc, PocketIcServer } from 'pic-ic';
 export declare class BenchReplica {
     type: 'dfx' | 'pocket-ic';
     verbose: boolean;
@@ -7,6 +7,7 @@ export declare class BenchReplica {
         canisterId: string;
         actor: any;
     }>;
+    pocketIcServer?: PocketIcServer;
     pocketIc?: PocketIc;
     constructor(type: 'dfx' | 'pocket-ic', verbose?: boolean);
     start({ silent }?: {

package/dist/commands/bench-replica.js

@@ -3,7 +3,7 @@ import { execSync } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
 import { execaCommand } from 'execa';
-import { PocketIc } from 'pic-ic';
+import { PocketIc, PocketIcServer } from 'pic-ic';
 import { getRootDir, readConfig } from '../mops.js';
 import { createActor, idlFactory } from '../declarations/bench/index.js';
 import { toolchain } from './toolchain/index.js';
@@ -25,11 +25,14 @@ export class BenchReplica {
         else {
             let pocketIcBin = await toolchain.bin('pocket-ic');
             let config = readConfig();
-            if (config.toolchain?.['pocket-ic'] !== '1.0.0') {
-                console.error('Currently only pocket-ic 1.0.0 is supported');
+            if (config.toolchain?.['pocket-ic'] !== '4.0.0') {
+                console.error('Current Mops CLI only supports pocket-ic 4.0.0');
                 process.exit(1);
             }
-            this.pocketIc = await PocketIc.create(pocketIcBin);
+            this.pocketIcServer = await PocketIcServer.start({
+                binPath: pocketIcBin,
+            });
+            this.pocketIc = await PocketIc.create(this.pocketIcServer.getUrl());
         }
     }
     async stop() {
@@ -37,8 +40,9 @@ export class BenchReplica {
             let dir = path.join(getRootDir(), '.mops/.bench');
             execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe'] });
         }
-        else if (this.pocketIc) {
+        else if (this.pocketIc && this.pocketIcServer) {
             await this.pocketIc.tearDown();
+            await this.pocketIcServer.stop();
         }
     }
     async deploy(name, wasm, cwd = process.cwd()) {
@@ -53,7 +57,7 @@ export class BenchReplica {
             this.canisters[name] = { cwd, canisterId, actor };
         }
         else if (this.pocketIc) {
-            let { canisterId, actor } = await this.pocketIc.setupCanister(idlFactory, wasm);
+            let { canisterId, actor } = await this.pocketIc.setupCanister({ idlFactory, wasm });
             this.canisters[name] = {
                 cwd,
                 canisterId: canisterId.toText(),

package/dist/commands/bench.js

@@ -16,6 +16,7 @@ import { getDfxVersion } from '../helpers/get-dfx-version.js';
 import { getMocPath } from '../helpers/get-moc-path.js';
 import { sources } from './sources.js';
 import { BenchReplica } from './bench-replica.js';
+import { filesize } from 'filesize';
 let ignore = [
     '**/node_modules/**',
     '**/.mops/**',
@@ -27,8 +28,9 @@ let globConfig = {
     ignore: ignore,
 };
 export async function bench(filter = '', optionsArg = {}) {
+    let config = readConfig();
     let defaultOptions = {
-        replica: 'dfx',
+        replica: config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx',
         replicaVersion: '',
         compiler: 'moc',
         compilerVersion: getMocVersion(),
@@ -44,7 +46,6 @@ export async function bench(filter = '', optionsArg = {}) {
         options.replicaVersion = getDfxVersion();
     }
     else if (options.replica == 'pocket-ic') {
-        let config = readConfig();
         options.replicaVersion = config.toolchain?.['pocket-ic'] || '';
     }
     options.verbose && console.log(options);
@@ -68,7 +69,7 @@ export async function bench(filter = '', optionsArg = {}) {
     }
     files.sort();
     let benchDir = `${getRootDir()}/.mops/.bench/`;
-    fs.rmSync(benchDir, { recursive: true, force: true });
+    // fs.rmSync(benchDir, {recursive: true, force: true});
     fs.mkdirSync(benchDir, { recursive: true });
     if (!options.silent) {
         console.log('Benchmark files:');
@@ -110,7 +111,7 @@ export async function bench(filter = '', optionsArg = {}) {
     });
     options.silent || console.log('Stopping replica...');
     await replica.stop();
-    fs.rmSync(benchDir, { recursive: true, force: true });
+    // fs.rmSync(benchDir, {recursive: true, force: true});
     return benchResults;
 }
 function getMocArgs(options) {
@@ -171,9 +172,14 @@ async function runBenchFile(file, options, replica) {
     let results = new Map();
     let instructionsCells = Array.from({ length: schema.rows.length }, () => []);
     let heapCells = Array.from({ length: schema.rows.length }, () => []);
+    let logicalStableMemoryCells = Array.from({ length: schema.rows.length }, () => []);
+    let reclaimedCells = Array.from({ length: schema.rows.length }, () => []);
     let formatNumber = (n) => {
         return n.toLocaleString('en-US').replaceAll(',', '_');
     };
+    let formatSize = (n) => {
+        return filesize(n, { standard: 'iec', round: 2 });
+    };
     let getTable = (prop) => {
         let resArr = [['', ...schema.cols]];
         for (let [_rowIndex, row] of schema.rows.entries()) {
@@ -197,7 +203,17 @@ async function runBenchFile(file, options, replica) {
                         }
                     }
                     // add to table
-                    curRow.push(formatNumber(res[prop]) + diff);
+                    let value = '';
+                    if (prop == 'rts_logical_stable_memory_size') {
+                        value = formatSize(res[prop] * 65536n);
+                    }
+                    else if (prop === 'rts_heap_size' || prop == 'rts_reclaimed') {
+                        value = formatSize(res[prop]);
+                    }
+                    else {
+                        value = formatNumber(res[prop]);
+                    }
+                    curRow.push(value + diff);
                 }
                 else {
                     curRow.push('');
@@ -216,6 +232,8 @@ async function runBenchFile(file, options, replica) {
 			${schema.description ? '\n' + chalk.gray(schema.description) : ''}
 			\n\n${chalk.blue('Instructions')}\n\n${getTable('instructions')}
 			\n\n${chalk.blue('Heap')}\n\n${getTable('rts_heap_size')}
+			\n\n${chalk.blue('Stable Memory')}\n\n${getTable('rts_logical_stable_memory_size')}
+			\n\n${chalk.blue('Garbage Collection')}\n\n${getTable('rts_reclaimed')}
 		`);
     };
     if (!process.env.CI && !options.silent) {
@@ -230,6 +248,10 @@ async function runBenchFile(file, options, replica) {
             instructionsCells[rowIndex][colIndex] = res.instructions;
             // @ts-ignore
             heapCells[rowIndex][colIndex] = res.rts_heap_size;
+            // @ts-ignore
+            logicalStableMemoryCells[rowIndex][colIndex] = res.rts_logical_stable_memory_size;
+            // @ts-ignore
+            reclaimedCells[rowIndex][colIndex] = res.rts_reclaimed;
             if (!process.env.CI && !options.silent) {
                 printResults();
             }
@@ -277,6 +299,8 @@ async function runBenchFile(file, options, replica) {
         metrics: [
             ['instructions', instructionsCells],
             ['rts_heap_size', heapCells],
+            ['rts_logical_stable_memory_size', logicalStableMemoryCells],
+            ['rts_reclaimed', reclaimedCells],
         ],
     };
 }

package/dist/commands/publish.js

@@ -242,7 +242,7 @@ export async function publish(options = {}) {
     let reporter = new SilentReporter;
     if (options.test) {
         console.log('Running tests...');
-        await testWithReporter(reporter);
+        await testWithReporter(reporter, '', 'interpreter', config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx');
         if (reporter.failed > 0) {
             console.log(chalk.red('Error: ') + 'tests failed');
             process.exit(1);

package/dist/commands/replica.d.ts

@@ -0,0 +1,59 @@
+import { ChildProcessWithoutNullStreams } from 'node:child_process';
+import { PassThrough } from 'node:stream';
+import { IDL } from '@dfinity/candid';
+import { PocketIc, PocketIcServer } from 'pic-ic';
+type StartOptions = {
+    type?: 'dfx' | 'pocket-ic';
+    dir?: string;
+    verbose?: boolean;
+    silent?: boolean;
+};
+export declare class Replica {
+    type: 'dfx' | 'pocket-ic';
+    verbose: boolean;
+    canisters: Record<string, {
+        cwd: string;
+        canisterId: string;
+        actor: any;
+        stream: PassThrough;
+    }>;
+    pocketIcServer?: PocketIcServer;
+    pocketIc?: PocketIc;
+    dfxProcess?: ChildProcessWithoutNullStreams;
+    dir: string;
+    ttl: number;
+    start({ type, dir, verbose, silent }?: StartOptions): Promise<void>;
+    _attachCanisterLogHandler(proc: ChildProcessWithoutNullStreams): void;
+    stop(sigint?: boolean): Promise<void>;
+    deploy(name: string, wasm: string, idlFactory: IDL.InterfaceFactory, cwd?: string): Promise<{
+        cwd: string;
+        canisterId: string;
+        actor: any;
+        stream: PassThrough;
+    }>;
+    getActor(name: string): unknown;
+    getCanister(name: string): {
+        cwd: string;
+        canisterId: string;
+        actor: any;
+        stream: PassThrough;
+    } | undefined;
+    getCanisterId(name: string): string;
+    getCanisterStream(canisterId: string): PassThrough | null;
+    dfxJson(canisterName: string, wasmPath?: string, didPath?: string): {
+        version: number;
+        canisters: Record<string, any>;
+        defaults: {
+            build: {
+                packtool: string;
+            };
+        };
+        networks: {
+            local: {
+                type: string;
+                bind: string;
+            };
+        };
+    };
+}
+export {};