ic-mops 0.39.2 → 0.40.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++) {

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,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "0.39.2",
+  "version": "0.40.0",
   "type": "module",
   "bin": {
     "mops": "dist/bin/mops.js",

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/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/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/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;
-            };
-        };
-    };
-}

package/dist/commands/replica.js

@@ -1,103 +0,0 @@
-import { execSync, spawn } from 'node:child_process';
-import path from 'node:path';
-import fs from 'node:fs';
-import { execaCommand } from 'execa';
-import { PocketIc } from 'pic-ic';
-import { readConfig } from '../mops.js';
-import { createActor, idlFactory } from '../declarations/bench/index.js';
-import { toolchain } from './toolchain/index.js';
-export class Replica {
-    constructor(type, cwd, verbose = false) {
-        this.verbose = false;
-        this.canisters = {};
-        this.type = type;
-        this.verbose = verbose;
-        this.cwd = cwd;
-    }
-    async start() {
-        console.log(`Starting ${this.type} replica...`);
-        if (this.type == 'dfx') {
-            await this.stop();
-            fs.writeFileSync(path.join(this.cwd, 'dfx.json'), JSON.stringify(this.dfxJson(''), null, 2));
-            // this.process = spawn('dfx start --background --clean --artificial-delay 0' + (this.verbose ? '' : ' -qqqq'), {cwd: this.cwd, stdio: ['inherit', this.verbose ? 'inherit' : 'ignore', 'inherit']});
-            this.process = spawn('dfx', ['start', '--background', '--clean', '--artificial-delay=0', this.verbose ? '' : ' -qqqq'].filter(x => x), { cwd: this.cwd });
-        }
-        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');
-                process.exit(1);
-            }
-            this.pocketIc = await PocketIc.create(pocketIcBin);
-            // @ts-ignore
-            this.process = this.pocketIc.server.serverProcess;
-        }
-        await new Promise((resolve, reject) => {
-            console.log(1);
-            this.process?.on('data', (data) => {
-                console.log(111, data);
-            });
-        });
-        return this.process;
-    }
-    async stop() {
-        if (this.type == 'dfx') {
-            execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), { cwd: this.cwd, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe'] });
-        }
-        else if (this.pocketIc) {
-            await this.pocketIc.tearDown();
-        }
-    }
-    async deploy(name, wasm, cwd = process.cwd()) {
-        if (this.type === 'dfx') {
-            await execaCommand(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, { cwd, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
-            let canisterId = execSync(`dfx canister id ${name}`, { cwd }).toString().trim();
-            let actor = await createActor(canisterId, {
-                agentOptions: {
-                    host: 'http://127.0.0.1:4944',
-                },
-            });
-            this.canisters[name] = { cwd, canisterId, actor };
-        }
-        else if (this.pocketIc) {
-            let { canisterId, actor } = await this.pocketIc.setupCanister(idlFactory, wasm);
-            this.canisters[name] = {
-                cwd,
-                canisterId: canisterId.toText(),
-                actor,
-            };
-        }
-    }
-    getActor(name) {
-        return this.canisters[name]?.actor;
-    }
-    getCanisterId(name) {
-        return this.canisters[name]?.canisterId || '';
-    }
-    dfxJson(canisterName) {
-        let canisters = {};
-        if (canisterName) {
-            canisters[canisterName] = {
-                type: 'custom',
-                wasm: 'canister.wasm',
-                candid: 'canister.did',
-            };
-        }
-        return {
-            version: 1,
-            canisters,
-            defaults: {
-                build: {
-                    packtool: 'mops sources',
-                },
-            },
-            networks: {
-                local: {
-                    type: 'ephemeral',
-                    bind: '127.0.0.1:4944',
-                },
-            },
-        };
-    }
-}