ic-mops 0.31.1 → 0.31.2

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

@@ -0,0 +1,94 @@
+import Nat64 "mo:base/Nat64";
+import Nat "mo:base/Nat";
+import Debug "mo:base/Debug";
+import ExperimentalInternetComputer "mo:base/ExperimentalInternetComputer";
+import Prim "mo:prim";
+import Bench "mo:bench";
+
+import UserBench "./user-bench";
+
+actor class() {
+	var benchOpt : ?Bench.Bench = null;
+
+	public func init() : async Bench.BenchSchema {
+		let bench = UserBench.init();
+		benchOpt := ?bench;
+		bench.getSchema();
+	};
+
+	public query func getSchema() : async Bench.BenchSchema {
+		let ?bench = benchOpt else Debug.trap("bench not initialized");
+		bench.getSchema();
+	};
+
+	func _getStats() : Bench.BenchResult {
+		{
+			instructions = 0;
+			rts_heap_size = Prim.rts_heap_size();
+			rts_memory_size = Prim.rts_memory_size();
+			rts_total_allocation = Prim.rts_total_allocation();
+			rts_mutator_instructions = Prim.rts_mutator_instructions();
+			rts_collector_instructions = Prim.rts_collector_instructions();
+		}
+	};
+
+	func _runCell(rowIndex : Nat, colIndex : Nat) : Bench.BenchResult {
+		let ?bench = benchOpt else Debug.trap("bench not initialized");
+		let statsBefore = _getStats();
+
+		let instructions = ExperimentalInternetComputer.countInstructions(func() {
+			bench.runCell(rowIndex, colIndex);
+		});
+
+		// await (func() : async () {})();
+
+		let statsAfter = _getStats();
+
+		{
+			instructions = Nat64.toNat(instructions);
+			rts_heap_size = statsAfter.rts_heap_size - statsBefore.rts_heap_size;
+			rts_memory_size = statsAfter.rts_memory_size - statsBefore.rts_memory_size;
+			rts_total_allocation = statsAfter.rts_total_allocation - statsBefore.rts_total_allocation;
+			rts_mutator_instructions = statsAfter.rts_mutator_instructions - statsBefore.rts_mutator_instructions;
+			rts_collector_instructions = statsAfter.rts_collector_instructions - statsBefore.rts_collector_instructions;
+		}
+	};
+
+	func _runCellAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		let ?bench = benchOpt else Debug.trap("bench not initialized");
+		let statsBefore = _getStats();
+
+		let instructions = ExperimentalInternetComputer.countInstructions(func() {
+			bench.runCell(rowIndex, colIndex);
+		});
+
+		await (func() : async () {})();
+
+		let statsAfter = _getStats();
+
+		{
+			instructions = Nat64.toNat(instructions);
+			rts_heap_size = statsAfter.rts_heap_size - statsBefore.rts_heap_size;
+			rts_memory_size = statsAfter.rts_memory_size - statsBefore.rts_memory_size;
+			rts_total_allocation = statsAfter.rts_total_allocation - statsBefore.rts_total_allocation;
+			rts_mutator_instructions = statsAfter.rts_mutator_instructions - statsBefore.rts_mutator_instructions;
+			rts_collector_instructions = statsAfter.rts_collector_instructions - statsBefore.rts_collector_instructions;
+		}
+	};
+
+	public query func getStats() : async Bench.BenchResult {
+		_getStats();
+	};
+
+	public query func runCellQuery(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		_runCell(rowIndex, colIndex);
+	};
+
+	public func runCellUpdate(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		await _runCellAwait(rowIndex, colIndex);
+	};
+
+	public func runCellUpdateAwait(rowIndex : Nat, colIndex : Nat) : async Bench.BenchResult {
+		_runCell(rowIndex, colIndex);
+	};
+};

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

@@ -0,0 +1,14 @@
+import Nat "mo:base/Nat";
+import Iter "mo:base/Iter";
+import Buffer "mo:base/Buffer";
+import Vector "mo:vector/Class";
+import Bench "mo:bench";
+
+// placeholder file that will be replaced with the *.bench.mo file
+module {
+	public func init() : Bench.Bench {
+		let bench = Bench.Bench();
+		// benchmark code goes here...
+		bench;
+	};
+};

package/dist/commands/bench.d.ts

@@ -0,0 +1,11 @@
+type BenchOptions = {
+    dfx?: string;
+    moc?: string;
+    gc?: 'copying' | 'compacting' | 'generational' | 'incremental';
+    forceGc?: boolean;
+    save?: boolean;
+    compare?: boolean;
+    verbose?: boolean;
+};
+export declare function bench(filter?: string, options?: BenchOptions): Promise<boolean>;
+export {};

package/dist/commands/bench.js

@@ -0,0 +1,268 @@
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import chalk from 'chalk';
+import { globSync } from 'glob';
+import { markdownTable } from 'markdown-table';
+import logUpdate from 'log-update';
+import { getRootDir } from '../mops.js';
+import { parallel } from '../parallel.js';
+import { createActor } from '../declarations/bench/index.js';
+import { absToRel } from './test/utils.js';
+import { getMocVersion } from '../helpers/get-moc-version.js';
+import { getDfxVersion } from '../helpers/get-dfx-version.js';
+import { getMocPath } from '../helpers/get-moc-path.js';
+import { sources } from './sources.js';
+import { execaCommand } from 'execa';
+let ignore = [
+    '**/node_modules/**',
+    '**/.mops/**',
+    '**/.vessel/**',
+    '**/.git/**',
+];
+let globConfig = {
+    nocase: true,
+    ignore: ignore,
+};
+export async function bench(filter = '', options = {}) {
+    let defaultOptions = {
+        moc: getMocVersion(),
+        dfx: getDfxVersion(),
+        gc: 'incremental',
+        forceGc: true,
+        save: false,
+        compare: false,
+        verbose: false,
+    };
+    options = { ...defaultOptions, ...options };
+    console.log(options);
+    let rootDir = getRootDir();
+    let globStr = '**/bench?(mark)/**/*.bench.mo';
+    if (filter) {
+        globStr = `**/bench?(mark)/**/*${filter}*.mo`;
+    }
+    let files = globSync(path.join(rootDir, globStr), globConfig);
+    if (!files.length) {
+        if (filter) {
+            console.log(`No benchmark files found for filter '${filter}'`);
+            return false;
+        }
+        console.log('No *.bench.mo files found');
+        console.log('Put your benchmark code in \'bench\' directory in *.bench.mo files');
+        return false;
+    }
+    files.sort();
+    let benchDir = `${getRootDir()}/.mops/.bench/`;
+    fs.rmSync(benchDir, { recursive: true, force: true });
+    fs.mkdirSync(benchDir, { recursive: true });
+    console.log('Benchmark files:');
+    for (let file of files) {
+        console.log(chalk.gray(`• ${absToRel(file)}`));
+    }
+    console.log('');
+    console.log('='.repeat(50));
+    console.log('');
+    console.log('Starting dfx replica...');
+    startDfx(options.verbose);
+    console.log('Deploying canisters...');
+    await parallel(os.cpus().length, files, async (file) => {
+        await deployBenchFile(file, options);
+    });
+    await parallel(1, files, async (file) => {
+        console.log('\n' + '—'.repeat(50));
+        console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
+        console.log('');
+        try {
+            await runBenchFile(file, options);
+        }
+        catch (err) {
+            console.error('Unexpected error. Stopping dfx replica...');
+            stopDfx(options.verbose);
+            throw err;
+        }
+    });
+    console.log('Stopping dfx replica...');
+    stopDfx(options.verbose);
+    fs.rmSync(benchDir, { recursive: true, force: true });
+    return true;
+}
+function getMocArgs(options) {
+    let args = '';
+    if (options.forceGc) {
+        args += ' --force-gc';
+    }
+    if (options.gc) {
+        args += ` --${options.gc}-gc`;
+    }
+    return args;
+}
+function dfxJson(canisterName, options = {}) {
+    options || console.log(options);
+    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:4947',
+            },
+        },
+    };
+}
+function startDfx(verbose = false) {
+    stopDfx(verbose);
+    let dir = path.join(getRootDir(), '.mops/.bench');
+    fs.writeFileSync(path.join(dir, 'dfx.json'), JSON.stringify(dfxJson(''), null, 2));
+    execSync('dfx start --background --clean' + (verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['inherit', verbose ? 'inherit' : 'ignore', 'inherit'] });
+}
+function stopDfx(verbose = false) {
+    let dir = path.join(getRootDir(), '.mops/.bench');
+    execSync('dfx stop' + (verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['pipe', verbose ? 'inherit' : 'ignore', 'pipe'] });
+}
+async function deployBenchFile(file, options = {}) {
+    let rootDir = getRootDir();
+    let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
+    let canisterName = path.parse(file).name;
+    // prepare temp files
+    fs.mkdirSync(tempDir, { recursive: true });
+    fs.writeFileSync(path.join(tempDir, 'dfx.json'), JSON.stringify(dfxJson(canisterName, options), null, 2));
+    fs.cpSync(new URL('./bench/bench-canister.mo', import.meta.url), path.join(tempDir, 'canister.mo'));
+    fs.cpSync(file, path.join(tempDir, 'user-bench.mo'));
+    // build canister
+    let mocPath = getMocPath();
+    let mocArgs = getMocArgs(options);
+    options.verbose && console.time(`build ${canisterName}`);
+    await execaCommand(`${mocPath} -c --idl canister.mo ${mocArgs} ${(await sources({ cwd: tempDir })).join(' ')}`, { cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+    options.verbose && console.timeEnd(`build ${canisterName}`);
+    // deploy canister
+    options.verbose && console.time(`deploy ${canisterName}`);
+    await execaCommand(`dfx deploy ${canisterName} --mode reinstall --yes --identity anonymous`, { cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+    options.verbose && console.timeEnd(`deploy ${canisterName}`);
+    // init bench
+    options.verbose && console.time(`init ${canisterName}`);
+    let canisterId = execSync(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
+    let actor = await createActor(canisterId, {
+        agentOptions: {
+            host: 'http://127.0.0.1:4947',
+        },
+    });
+    await actor.init();
+    options.verbose && console.timeEnd(`init ${canisterName}`);
+}
+async function runBenchFile(file, options = {}) {
+    let rootDir = getRootDir();
+    let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
+    let canisterName = path.parse(file).name;
+    let canisterId = execSync(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
+    let actor = await createActor(canisterId, {
+        agentOptions: {
+            host: 'http://127.0.0.1:4947',
+        },
+    });
+    let schema = await actor.getSchema();
+    // load previous results
+    let prevResults;
+    let resultsJsonFile = path.join(rootDir, '.bench', `${path.parse(file).name}.json`);
+    if (options.compare) {
+        if (fs.existsSync(resultsJsonFile)) {
+            let prevResultsJson = JSON.parse(fs.readFileSync(resultsJsonFile).toString());
+            prevResults = new Map(prevResultsJson.results);
+        }
+        else {
+            console.log(chalk.yellow(`No previous results found "${resultsJsonFile}"`));
+        }
+    }
+    let results = new Map();
+    let formatNumber = (n) => {
+        return n.toLocaleString('en-US').replaceAll(',', '_');
+    };
+    let getTable = (prop) => {
+        let resArr = [['', ...schema.cols]];
+        for (let [_rowIndex, row] of schema.rows.entries()) {
+            let curRow = [row];
+            for (let [_colIndex, col] of schema.cols.entries()) {
+                let res = results.get(`${row}:${col}`);
+                if (res) {
+                    // compare with previous results
+                    let diff = '';
+                    if (options.compare && prevResults) {
+                        let prevRes = prevResults.get(`${row}:${col}`);
+                        if (prevRes) {
+                            let percent = (Number(res[prop]) - Number(prevRes[prop])) / Number(prevRes[prop]) * 100;
+                            let sign = percent > 0 ? '+' : '';
+                            let percentText = percent == 0 ? '0%' : sign + percent.toFixed(2) + '%';
+                            // diff = ' (' + (percent > 0 ? chalk.red(percentText) : chalk.green(percentText)) + ')'; // alignment is broken
+                            diff = ' (' + percentText + ')';
+                        }
+                        else {
+                            diff = chalk.yellow(' (no previous results)');
+                        }
+                    }
+                    // add to table
+                    curRow.push(formatNumber(res[prop]) + diff);
+                }
+                else {
+                    curRow.push('');
+                }
+            }
+            resArr.push(curRow);
+        }
+        return markdownTable(resArr, { align: ['l', ...'r'.repeat(schema.cols.length)] });
+    };
+    let printResults = () => {
+        logUpdate(`
+			\n${chalk.bold(schema.name)}
+			${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')}
+		`);
+    };
+    printResults();
+    // run all cells
+    for (let [rowIndex, row] of schema.rows.entries()) {
+        for (let [colIndex, col] of schema.cols.entries()) {
+            let res = await actor.runCellQuery(BigInt(rowIndex), BigInt(colIndex));
+            // let res = await actor.runCellUpdate(BigInt(rowIndex), BigInt(colIndex));
+            // let res = await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
+            results.set(`${row}:${col}`, res);
+            printResults();
+        }
+    }
+    logUpdate.done();
+    // save results
+    if (options.save) {
+        console.log(`Saving results to ${chalk.gray(absToRel(resultsJsonFile))}`);
+        let json = {
+            version: 1,
+            moc: options.moc,
+            dfx: options.dfx,
+            gc: options.gc,
+            forceGc: options.forceGc,
+            results: Array.from(results.entries()),
+        };
+        fs.mkdirSync(path.dirname(resultsJsonFile), { recursive: true });
+        fs.writeFileSync(resultsJsonFile, JSON.stringify(json, (_, val) => {
+            if (typeof val === 'bigint') {
+                return Number(val);
+            }
+            else {
+                return val;
+            }
+        }, 2));
+    }
+    return { schema, results };
+}

package/dist/declarations/bench/bench.did

@@ -0,0 +1,26 @@
+type anon_class_10_1 = 
+ service {
+   getSchema: () -> (BenchSchema) query;
+   getStats: () -> (BenchResult) query;
+   init: () -> (BenchSchema);
+   runCellQuery: (nat, nat) -> (BenchResult) query;
+   runCellUpdate: (nat, nat) -> (BenchResult);
+   runCellUpdateAwait: (nat, nat) -> (BenchResult);
+ };
+type BenchSchema = 
+ record {
+   cols: vec text;
+   description: text;
+   name: text;
+   rows: vec text;
+ };
+type BenchResult = 
+ record {
+   instructions: int;
+   rts_collector_instructions: int;
+   rts_heap_size: int;
+   rts_memory_size: int;
+   rts_mutator_instructions: int;
+   rts_total_allocation: int;
+ };
+service : () -> anon_class_10_1

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

@@ -0,0 +1,26 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+
+export interface BenchResult {
+  'instructions' : bigint,
+  'rts_memory_size' : bigint,
+  'rts_total_allocation' : bigint,
+  'rts_collector_instructions' : bigint,
+  'rts_mutator_instructions' : bigint,
+  'rts_heap_size' : bigint,
+}
+export interface BenchSchema {
+  'cols' : Array<string>,
+  'name' : string,
+  'rows' : Array<string>,
+  'description' : string,
+}
+export interface anon_class_10_1 {
+  'getSchema' : ActorMethod<[], BenchSchema>,
+  'getStats' : ActorMethod<[], BenchResult>,
+  'init' : ActorMethod<[], BenchSchema>,
+  'runCellQuery' : ActorMethod<[bigint, bigint], BenchResult>,
+  'runCellUpdate' : ActorMethod<[bigint, bigint], BenchResult>,
+  'runCellUpdateAwait' : ActorMethod<[bigint, bigint], BenchResult>,
+}
+export interface _SERVICE extends anon_class_10_1 {}

package/dist/declarations/bench/bench.did.js

@@ -0,0 +1,26 @@
+export const idlFactory = ({ IDL }) => {
+  const BenchSchema = IDL.Record({
+    'cols' : IDL.Vec(IDL.Text),
+    'name' : IDL.Text,
+    'rows' : IDL.Vec(IDL.Text),
+    'description' : IDL.Text,
+  });
+  const BenchResult = IDL.Record({
+    'instructions' : IDL.Int,
+    'rts_memory_size' : IDL.Int,
+    'rts_total_allocation' : IDL.Int,
+    'rts_collector_instructions' : IDL.Int,
+    'rts_mutator_instructions' : IDL.Int,
+    'rts_heap_size' : IDL.Int,
+  });
+  const anon_class_10_1 = IDL.Service({
+    'getSchema' : IDL.Func([], [BenchSchema], ['query']),
+    'getStats' : IDL.Func([], [BenchResult], ['query']),
+    'init' : IDL.Func([], [BenchSchema], []),
+    'runCellQuery' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], ['query']),
+    'runCellUpdate' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
+    'runCellUpdateAwait' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
+  });
+  return anon_class_10_1;
+};
+export const init = ({ IDL }) => { return []; };

package/dist/declarations/bench/index.d.ts

@@ -0,0 +1,50 @@
+import type {
+  ActorSubclass,
+  HttpAgentOptions,
+  ActorConfig,
+  Agent,
+} from "@dfinity/agent";
+import type { Principal } from "@dfinity/principal";
+import type { IDL } from "@dfinity/candid";
+
+import { _SERVICE } from './bench.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const bench: ActorSubclass<_SERVICE>;

package/dist/declarations/bench/index.js

@@ -0,0 +1,41 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from "./bench.did.js";
+export { idlFactory } from "./bench.did.js";
+
+/* CANISTER_ID is replaced by webpack based on node environment
+ * Note: canister environment variable will be standardized as
+ * process.env.CANISTER_ID_<CANISTER_NAME_UPPERCASE>
+ * beginning in dfx 0.15.0
+ */
+export const canisterId =
+  process.env.CANISTER_ID_BENCH ||
+  process.env.BENCH_CANISTER_ID;
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({ ...options.agentOptions });
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      "Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent."
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== "ic") {
+    agent.fetchRootKey().catch((err) => {
+      console.warn(
+        "Unable to fetch root key. Check to ensure that your local replica is running"
+      );
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions,
+  });
+};

package/dist/helpers/get-dfx-version.d.ts

@@ -0,0 +1 @@
+export declare function getDfxVersion(): string;

package/dist/helpers/get-dfx-version.js

@@ -0,0 +1,9 @@
+import { execSync } from 'node:child_process';
+export function getDfxVersion() {
+    try {
+        let res = execSync('dfx --version').toString();
+        return res.trim().split('dfx ')[1] || '';
+    }
+    catch { }
+    return '';
+}

package/dist/helpers/get-moc-path.d.ts

@@ -0,0 +1 @@
+export declare function getMocPath(): string;

package/dist/helpers/get-moc-path.js

@@ -0,0 +1,11 @@
+import { execSync } from 'node:child_process';
+export function getMocPath() {
+    let mocPath = process.env.DFX_MOC_PATH;
+    if (!mocPath) {
+        mocPath = execSync('dfx cache show').toString().trim() + '/moc';
+    }
+    if (!mocPath) {
+        mocPath = 'moc';
+    }
+    return mocPath;
+}

package/dist/helpers/get-moc-version.d.ts

@@ -0,0 +1 @@
+export declare function getMocVersion(): string;

package/dist/helpers/get-moc-version.js

@@ -0,0 +1,7 @@
+import { execSync } from 'node:child_process';
+import { getMocPath } from './get-moc-path.js';
+export function getMocVersion() {
+    let mocPath = getMocPath();
+    let match = execSync(mocPath).toString().trim().match(/Motoko compiler ([^\s]+) .*/);
+    return match?.[1] || '';
+}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ic-mops",
-	"version": "0.31.1",
+	"version": "0.31.2",
 	"type": "module",
 	"bin": {
 		"mops": "dist/cli.js"

package/dist/resolve-packages.js

@@ -57,7 +57,7 @@ export async function resolvePackages({ verbose = false } = {}) {
             let nestedConfig;
             if (repo) {
                 const dir = formatGithubDir(name, repo);
-                nestedConfig = await readVesselConfig(dir) || {};
+                nestedConfig = await readVesselConfig(dir, { silent: true }) || {};
             }
             else if (!pkgDetails.path && version) {
                 const file = formatDir(name, version) + '/mops.toml';

package/dist/vessel.d.ts

@@ -8,8 +8,9 @@ export type VesselDependencies = Array<{
     repo?: string;
     path?: string;
 }>;
-export declare const readVesselConfig: (dir: string, { cache }?: {
+export declare const readVesselConfig: (dir: string, { cache, silent }?: {
     cache?: boolean | undefined;
+    silent?: boolean | undefined;
 }) => Promise<VesselConfig | null>;
 export declare const downloadFromGithub: (repo: string, dest: string, onProgress: any) => Promise<unknown>;
 export declare const installFromGithub: (name: string, repo: string, { verbose, dep, silent }?: {

package/dist/vessel.js

@@ -9,7 +9,7 @@ import decompress from 'decompress';
 import { pipeline } from 'stream';
 import { formatGithubDir, parseGithubURL, progressBar } from './mops.js';
 import { addCache, copyCache, isCached } from './cache.js';
-const dhallFileToJson = async (filePath) => {
+const dhallFileToJson = async (filePath, silent) => {
     if (existsSync(filePath)) {
         let cwd = new URL(path.dirname(import.meta.url)).pathname;
         let res;
@@ -17,7 +17,7 @@ const dhallFileToJson = async (filePath) => {
             res = await execaCommand(`dhall-to-json --file ${filePath}`, { preferLocal: true, cwd });
         }
         catch (err) {
-            console.error('dhall-to-json error:', err);
+            silent || console.error('dhall-to-json error:', err.message?.split('Message:')[0]);
             return null;
         }
         if (res.exitCode === 0) {
@@ -29,15 +29,15 @@ const dhallFileToJson = async (filePath) => {
     }
     return null;
 };
-export const readVesselConfig = async (dir, { cache = true } = {}) => {
+export const readVesselConfig = async (dir, { cache = true, silent = false } = {}) => {
     const cachedFile = (dir || process.cwd()) + '/vessel.json';
     if (existsSync(cachedFile)) {
         let cachedConfig = readFileSync(cachedFile).toString();
         return JSON.parse(cachedConfig);
     }
     const [vessel, packageSetArray] = await Promise.all([
-        dhallFileToJson((dir || process.cwd()) + '/vessel.dhall'),
-        dhallFileToJson((dir || process.cwd()) + '/package-set.dhall')
+        dhallFileToJson((dir || process.cwd()) + '/vessel.dhall', silent),
+        dhallFileToJson((dir || process.cwd()) + '/package-set.dhall', silent)
     ]);
     if (!vessel || !packageSetArray) {
         return null;
@@ -64,6 +64,8 @@ export const downloadFromGithub = async (repo, dest, onProgress) => {
     const readStream = got.stream(zipFile);
     const promise = new Promise((resolve, reject) => {
         readStream.on('error', (err) => {
+            console.error(chalk.red(`Error: failed to download from GitHub: ${zipFile}`));
+            console.error(err.message);
             reject(err);
         });
         readStream.on('downloadProgress', ({ transferred, total }) => {
@@ -135,7 +137,7 @@ export const installFromGithub = async (name, repo, { verbose = false, dep = fal
         }
         catch (err) {
             deleteSync([dir]);
-            throw err;
+            process.exit(1);
         }
         // add to cache
         await addCache(cacheName, dir);
@@ -143,7 +145,7 @@ export const installFromGithub = async (name, repo, { verbose = false, dep = fal
     if (verbose) {
         silent || logUpdate.done();
     }
-    const config = await readVesselConfig(dir);
+    const config = await readVesselConfig(dir, { silent });
     if (config) {
         for (const { name, repo } of config.dependencies) {
             if (repo) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ic-mops",
-	"version": "0.31.1",
+	"version": "0.31.2",
 	"type": "module",
 	"bin": {
 		"mops": "dist/cli.js"

package/resolve-packages.ts

@@ -71,7 +71,7 @@ export async function resolvePackages({verbose = false} = {}): Promise<Record<st
 
 			if (repo) {
 				const dir = formatGithubDir(name, repo);
-				nestedConfig = await readVesselConfig(dir) || {};
+				nestedConfig = await readVesselConfig(dir, {silent: true}) || {};
 			}
 			else if (!pkgDetails.path && version) {
 				const file = formatDir(name, version) + '/mops.toml';

package/vessel.ts

@@ -10,15 +10,15 @@ import {pipeline} from 'stream';
 import {formatGithubDir, parseGithubURL, progressBar} from './mops.js';
 import {addCache, copyCache, isCached} from './cache.js';
 
-const dhallFileToJson = async (filePath: string) => {
+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) {
-			console.error('dhall-to-json error:', err);
+		catch (err: any) {
+			silent || console.error('dhall-to-json error:', err.message?.split('Message:')[0]);
 			return null;
 		}
 
@@ -45,7 +45,7 @@ export type VesselDependencies = Array<{
 	path?: string; // local package
 }>;
 
-export const readVesselConfig = async (dir: string, {cache = true} = {}): 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)) {
@@ -54,8 +54,8 @@ export const readVesselConfig = async (dir: string, {cache = true} = {}): Promis
 	}
 
 	const [vessel, packageSetArray] = await Promise.all([
-		dhallFileToJson((dir || process.cwd()) + '/vessel.dhall'),
-		dhallFileToJson((dir || process.cwd()) + '/package-set.dhall')
+		dhallFileToJson((dir || process.cwd()) + '/vessel.dhall', silent),
+		dhallFileToJson((dir || process.cwd()) + '/package-set.dhall', silent)
 	]);
 
 	if (!vessel || !packageSetArray) {
@@ -90,6 +90,8 @@ export const downloadFromGithub = async (repo: string, dest: string, onProgress:
 
 	const promise = new Promise((resolve, reject) => {
 		readStream.on('error', (err) => {
+			console.error(chalk.red(`Error: failed to download from GitHub: ${zipFile}`));
+			console.error(err.message);
 			reject(err);
 		});
 
@@ -172,7 +174,7 @@ export const installFromGithub = async (name: string, repo: string, {verbose = f
 		}
 		catch (err) {
 			deleteSync([dir]);
-			throw err;
+			process.exit(1);
 		}
 
 		// add to cache
@@ -183,7 +185,7 @@ export const installFromGithub = async (name: string, repo: string, {verbose = f
 		silent || logUpdate.done();
 	}
 
-	const config = await readVesselConfig(dir);
+	const config = await readVesselConfig(dir, {silent});
 
 	if (config) {
 		for (const {name, repo} of config.dependencies) {