ic-mops 0.29.0 → 0.31.0

package/cli.ts

@@ -135,8 +135,9 @@ program
 program
 	.command('import-identity <data>')
 	.description('Import .pem file data to use as identity')
-	.action(async (data) => {
-		await importPem(data);
+	.addOption(new Option('--no-encrypt', 'Do not ask for a password to encrypt identity'))
+	.action(async (data, options) => {
+		await importPem(data, options);
 		await whoami();
 	});
 

package/commands/add.ts

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import chalk from 'chalk';
 import logUpdate from 'log-update';
-import {checkConfigFile, getHighestVersion, parseGithubURL, readConfig, writeConfig} from '../mops.js';
+import {checkConfigFile, getGithubCommit, getHighestVersion, parseGithubURL, readConfig, writeConfig} from '../mops.js';
 import {installFromGithub} from '../vessel.js';
 import {install} from './install.js';
 import {notifyInstalls} from '../notify-installs.js';
@@ -36,11 +36,20 @@ export async function add(name: string, {verbose = false, dev = false} = {}) {
 	}
 	// github package
 	else if (name.startsWith('https://github.com') || name.split('/').length > 1) {
-		const {org, gitName, branch} = parseGithubURL(name);
+		let {org, gitName, branch, commitHash} = parseGithubURL(name);
+
+		// fetch latest commit hash of branch if not specified
+		if (!commitHash) {
+			let commit = await getGithubCommit(`${org}/${gitName}`, branch);
+			if (!commit.sha) {
+				throw Error(`Could not find commit hash for ${name}`);
+			}
+			commitHash = commit.sha;
+		}
 
 		pkgDetails = {
 			name: parseGithubURL(name).gitName,
-			repo: `https://github.com/${org}/${gitName}#${branch}`,
+			repo: `https://github.com/${org}/${gitName}#${branch}@${commitHash}`,
 			version: '',
 		};
 	}

package/commands/import-identity.ts

@@ -6,28 +6,36 @@ import {deleteSync} from 'del';
 import {globalConfigDir} from '../mops.js';
 import {encrypt} from '../pem.js';
 
-export async function importPem(data: string) {
+type ImportIdentityOptions = {
+	encrypt: boolean;
+};
+
+export async function importPem(data: string, options: ImportIdentityOptions = {encrypt: true}) {
 	try {
 		if (!fs.existsSync(globalConfigDir)) {
 			fs.mkdirSync(globalConfigDir);
 		}
 
-		let res = await prompts({
-			type: 'password',
-			name: 'password',
-			message: 'Enter password to encrypt identity.pem',
-		});
-		let password = res.password;
+		let password = '';
 
-		if (!password) {
+		if (options.encrypt) {
 			let res = await prompts({
-				type: 'confirm',
-				name: 'ok',
-				message: 'Are you sure you don\'t want to protect your identity.pem with a password?',
+				type: 'invisible',
+				name: 'password',
+				message: 'Enter password to encrypt identity.pem',
 			});
-			if (!res.ok) {
-				console.log('aborted');
-				return;
+			password = res.password;
+
+			if (!password) {
+				let res = await prompts({
+					type: 'confirm',
+					name: 'ok',
+					message: 'Are you sure you don\'t want to protect your identity.pem with a password?',
+				});
+				if (!res.ok) {
+					console.log('aborted');
+					return;
+				}
 			}
 		}
 

package/commands/install.ts

@@ -36,13 +36,13 @@ export async function install(pkg: string, version = '', {verbose = false, silen
 
 	// already installed
 	if (fs.existsSync(dir)) {
-		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (already installed)`);
+		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (local cache)`);
 		alreadyInstalled = true;
 	}
 	// copy from cache
 	else if (isCached(`${pkg}@${version}`)) {
 		await copyCache(`${pkg}@${version}`, dir);
-		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (cache)`);
+		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (global cache)`);
 	}
 	// download
 	else {

package/commands/update.ts

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import {checkConfigFile, readConfig} from '../mops.js';
+import {checkConfigFile, getGithubCommit, parseGithubURL, readConfig} from '../mops.js';
 import {add} from './add.js';
 import {getAvailableUpdates} from './available-updates.js';
 
@@ -9,10 +9,38 @@ export async function update(pkg?: string) {
 	}
 	let config = readConfig();
 
+	if (pkg && !config.dependencies?.[pkg] && !config['dev-dependencies']?.[pkg]) {
+		console.log(chalk.red(`Package "${pkg}" is not installed!`));
+		return;
+	}
+
+	// update github packages
+	let deps = Object.values(config.dependencies || {});
+	let devDeps = Object.values(config['dev-dependencies'] || {});
+	let githubDeps = [...deps, ...devDeps].filter((dep) => dep.repo);
+	if (pkg) {
+		githubDeps = githubDeps.filter((dep) => dep.name === pkg);
+	}
+
+	for (let dep of githubDeps) {
+		let {org, gitName, branch, commitHash} = parseGithubURL(dep.repo || '');
+		let dev = !!config['dev-dependencies']?.[dep.name];
+		let commit = await getGithubCommit(`${org}/${gitName}`, branch);
+		if (commit.sha !== commitHash) {
+			await add(`https://github.com/${org}/${gitName}#${branch}@${commit.sha}`, {dev});
+		}
+	}
+
+	// update mops packages
 	let available = await getAvailableUpdates(config, pkg);
 
 	if (available.length === 0) {
-		console.log(chalk.green('All dependencies are up to date!'));
+		if (pkg) {
+			console.log(chalk.green(`Package "${pkg}" is up to date!`));
+		}
+		else {
+			console.log(chalk.green('All dependencies are up to date!'));
+		}
 	}
 	else {
 		for (let dep of available) {

package/dist/cli.js

@@ -121,8 +121,9 @@ program
 program
     .command('import-identity <data>')
     .description('Import .pem file data to use as identity')
-    .action(async (data) => {
-    await importPem(data);
+    .addOption(new Option('--no-encrypt', 'Do not ask for a password to encrypt identity'))
+    .action(async (data, options) => {
+    await importPem(data, options);
     await whoami();
 });
 // sources

package/dist/commands/add.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import chalk from 'chalk';
 import logUpdate from 'log-update';
-import { checkConfigFile, getHighestVersion, parseGithubURL, readConfig, writeConfig } from '../mops.js';
+import { checkConfigFile, getGithubCommit, getHighestVersion, parseGithubURL, readConfig, writeConfig } from '../mops.js';
 import { installFromGithub } from '../vessel.js';
 import { install } from './install.js';
 import { notifyInstalls } from '../notify-installs.js';
@@ -32,10 +32,18 @@ export async function add(name, { verbose = false, dev = false } = {}) {
     }
     // github package
     else if (name.startsWith('https://github.com') || name.split('/').length > 1) {
-        const { org, gitName, branch } = parseGithubURL(name);
+        let { org, gitName, branch, commitHash } = parseGithubURL(name);
+        // fetch latest commit hash of branch if not specified
+        if (!commitHash) {
+            let commit = await getGithubCommit(`${org}/${gitName}`, branch);
+            if (!commit.sha) {
+                throw Error(`Could not find commit hash for ${name}`);
+            }
+            commitHash = commit.sha;
+        }
         pkgDetails = {
             name: parseGithubURL(name).gitName,
-            repo: `https://github.com/${org}/${gitName}#${branch}`,
+            repo: `https://github.com/${org}/${gitName}#${branch}@${commitHash}`,
             version: '',
         };
     }

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

@@ -82,4 +82,8 @@ actor class() {
 	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.d.ts

@@ -1,10 +1,11 @@
 type BenchOptions = {
-    verbose?: boolean;
-    save?: boolean;
-    compare?: boolean;
     dfx?: string;
     moc?: string;
-    gc?: 'copying' | 'compacting' | 'generational' | 'incremental' | 'none';
+    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

@@ -12,6 +12,8 @@ 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';
 let ignore = [
     '**/node_modules/**',
     '**/.mops/**',
@@ -23,6 +25,16 @@ let globConfig = {
     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 };
     let rootDir = getRootDir();
     let globStr = '**/bench?(mark)/**/*.bench.mo';
     if (filter) {
@@ -35,7 +47,7 @@ export async function bench(filter = '', options = {}) {
             return false;
         }
         console.log('No *.bench.mo files found');
-        console.log('Put your benchmark files in \'bench\' directory in *.bench.mo files');
+        console.log('Put your benchmark code in \'bench\' directory in *.bench.mo files');
         return false;
     }
     files.sort();
@@ -48,17 +60,16 @@ export async function bench(filter = '', options = {}) {
     }
     console.log('');
     console.log('='.repeat(50));
+    console.log('');
     console.log('Starting dfx replica...');
     startDfx(options.verbose);
-    let resultsByName = new Map();
     // await parallel(os.cpus().length, files, async (file: string) => {
     await parallel(1, files, async (file) => {
         console.log('\n' + '—'.repeat(50));
         console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
         console.log('');
         try {
-            let { schema, results } = await runBenchFile(file, options);
-            resultsByName.set(schema.name || absToRel(file), results);
+            await runBenchFile(file, options);
         }
         catch (err) {
             console.error('Unexpected error. Stopping dfx replica...');
@@ -66,42 +77,36 @@ export async function bench(filter = '', options = {}) {
             throw err;
         }
     });
-    if (options.save) {
-        console.log('Saving results to mops.bench.json...');
-        let json = {
-            version: 1,
-            moc: options.moc || getMocVersion(),
-            dfx: options.dfx || getDfxVersion(),
-            gc: options.gc || 'incremental',
-            results: {},
-        };
-        resultsByName.forEach((results, name) => {
-            json.results[name] = Array.from(results.entries());
-        });
-        fs.writeFileSync(path.join(rootDir, 'mops.bench.json'), JSON.stringify(json, (_, val) => {
-            if (typeof val === 'bigint') {
-                return Number(val);
-            }
-            else {
-                return val;
-            }
-        }, 2));
-    }
     console.log('Stopping dfx replica...');
     stopDfx(options.verbose);
     fs.rmSync(benchDir, { recursive: true, force: true });
     return true;
 }
-function dfxJson(canisterName) {
+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: 'motoko',
+            type: 'custom',
+            wasm: 'canister.wasm',
+            candid: 'canister.did',
+            // args: getMocArgs(options),
+        };
+    }
     return {
         version: 1,
-        canisters: {
-            [canisterName]: {
-                type: 'motoko',
-                main: 'canister.mo',
-                args: '--force-gc --incremental-gc',
-            }
-        },
+        canisters,
         defaults: {
             build: {
                 packtool: 'mops sources',
@@ -119,21 +124,34 @@ 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', { cwd: dir, stdio: ['inherit', verbose ? 'inherit' : 'ignore', 'inherit'] });
+    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', { cwd: dir, stdio: ['pipe', verbose ? 'inherit' : 'ignore', 'pipe'] });
+    execSync('dfx stop' + (verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['pipe', verbose ? 'inherit' : 'ignore', 'pipe'] });
 }
-async function runBenchFile(file, options = {}) {
+async function buildBenchFile(file, options = {}) {
     let rootDir = getRootDir();
     let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
     fs.mkdirSync(tempDir, { recursive: true });
-    let canisterName = Date.now().toString(36);
+    // let canisterName = Date.now().toString(36);
+    let canisterName = path.parse(file).name;
     // prepare temp files
-    fs.writeFileSync(path.join(tempDir, 'dfx.json'), JSON.stringify(dfxJson(canisterName), null, 2));
+    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);
+    console.log(tempDir);
+    console.log(`${mocPath} -c --idl canister.mo ${mocArgs} ${(await sources({ cwd: tempDir })).join(' ')}`);
+    execSync(`${mocPath} -c --idl canister.mo ${mocArgs} ${(await sources({ cwd: tempDir })).join(' ')}`, { cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+}
+async function runBenchFile(file, options = {}) {
+    let rootDir = getRootDir();
+    await buildBenchFile(file, options);
+    let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
+    let canisterName = path.parse(file).name;
     // deploy canister
     execSync(`dfx deploy ${canisterName} --mode reinstall --yes --identity anonymous`, { cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
     let canisterId = execSync(`dfx canister id ${canisterName}`, { cwd: tempDir }).toString().trim();
@@ -145,13 +163,14 @@ async function runBenchFile(file, options = {}) {
     let schema = await actor.init();
     // load previous results
     let prevResults;
+    let resultsJsonFile = path.join(rootDir, '.bench', `${path.parse(file).name}.json`);
     if (options.compare) {
-        let prevResultsJson = JSON.parse(fs.readFileSync(path.join(rootDir, 'mops.bench.json')).toString());
-        if (prevResultsJson.results[schema.name]) {
-            prevResults = new Map(prevResultsJson.results[schema.name]);
+        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 for benchmark with name "${schema.name}"`));
+            console.log(chalk.yellow(`No previous results found "${resultsJsonFile}"`));
         }
     }
     let results = new Map();
@@ -205,10 +224,32 @@ async function runBenchFile(file, options = {}) {
         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/commands/import-identity.d.ts

@@ -1 +1,5 @@
-export declare function importPem(data: string): Promise<void>;
+type ImportIdentityOptions = {
+    encrypt: boolean;
+};
+export declare function importPem(data: string, options?: ImportIdentityOptions): Promise<void>;
+export {};

package/dist/commands/import-identity.js

@@ -5,26 +5,29 @@ import prompts from 'prompts';
 import { deleteSync } from 'del';
 import { globalConfigDir } from '../mops.js';
 import { encrypt } from '../pem.js';
-export async function importPem(data) {
+export async function importPem(data, options = { encrypt: true }) {
     try {
         if (!fs.existsSync(globalConfigDir)) {
             fs.mkdirSync(globalConfigDir);
         }
-        let res = await prompts({
-            type: 'password',
-            name: 'password',
-            message: 'Enter password to encrypt identity.pem',
-        });
-        let password = res.password;
-        if (!password) {
+        let password = '';
+        if (options.encrypt) {
             let res = await prompts({
-                type: 'confirm',
-                name: 'ok',
-                message: 'Are you sure you don\'t want to protect your identity.pem with a password?',
+                type: 'invisible',
+                name: 'password',
+                message: 'Enter password to encrypt identity.pem',
             });
-            if (!res.ok) {
-                console.log('aborted');
-                return;
+            password = res.password;
+            if (!password) {
+                let res = await prompts({
+                    type: 'confirm',
+                    name: 'ok',
+                    message: 'Are you sure you don\'t want to protect your identity.pem with a password?',
+                });
+                if (!res.ok) {
+                    console.log('aborted');
+                    return;
+                }
             }
         }
         let identityPem = path.resolve(globalConfigDir, 'identity.pem');

package/dist/commands/install.js

@@ -31,13 +31,13 @@ export async function install(pkg, version = '', { verbose = false, silent = fal
     let alreadyInstalled = false;
     // already installed
     if (fs.existsSync(dir)) {
-        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (already installed)`);
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (local cache)`);
         alreadyInstalled = true;
     }
     // copy from cache
     else if (isCached(`${pkg}@${version}`)) {
         await copyCache(`${pkg}@${version}`, dir);
-        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (cache)`);
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (global cache)`);
     }
     // download
     else {

package/dist/commands/update.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { checkConfigFile, readConfig } from '../mops.js';
+import { checkConfigFile, getGithubCommit, parseGithubURL, readConfig } from '../mops.js';
 import { add } from './add.js';
 import { getAvailableUpdates } from './available-updates.js';
 export async function update(pkg) {
@@ -7,9 +7,34 @@ export async function update(pkg) {
         return;
     }
     let config = readConfig();
+    if (pkg && !config.dependencies?.[pkg] && !config['dev-dependencies']?.[pkg]) {
+        console.log(chalk.red(`Package "${pkg}" is not installed!`));
+        return;
+    }
+    // update github packages
+    let deps = Object.values(config.dependencies || {});
+    let devDeps = Object.values(config['dev-dependencies'] || {});
+    let githubDeps = [...deps, ...devDeps].filter((dep) => dep.repo);
+    if (pkg) {
+        githubDeps = githubDeps.filter((dep) => dep.name === pkg);
+    }
+    for (let dep of githubDeps) {
+        let { org, gitName, branch, commitHash } = parseGithubURL(dep.repo || '');
+        let dev = !!config['dev-dependencies']?.[dep.name];
+        let commit = await getGithubCommit(`${org}/${gitName}`, branch);
+        if (commit.sha !== commitHash) {
+            await add(`https://github.com/${org}/${gitName}#${branch}@${commit.sha}`, { dev });
+        }
+    }
+    // update mops packages
     let available = await getAvailableUpdates(config, pkg);
     if (available.length === 0) {
-        console.log(chalk.green('All dependencies are up to date!'));
+        if (pkg) {
+            console.log(chalk.green(`Package "${pkg}" is up to date!`));
+        }
+        else {
+            console.log(chalk.green('All dependencies are up to date!'));
+        }
     }
     else {
         for (let dep of available) {

package/dist/declarations/bench/bench.did

@@ -4,6 +4,7 @@ type anon_class_10_1 =
    init: () -> (BenchSchema);
    runCellQuery: (nat, nat) -> (BenchResult) query;
    runCellUpdate: (nat, nat) -> (BenchResult);
+   runCellUpdateAwait: (nat, nat) -> (BenchResult);
  };
 type BenchSchema = 
  record {

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

@@ -20,5 +20,6 @@ export interface anon_class_10_1 {
   '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

@@ -18,6 +18,7 @@ export const idlFactory = ({ IDL }) => {
     '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;
 };

package/dist/integrity.d.ts

@@ -0,0 +1,4 @@
+export declare function getFileHashesFromRegistry(packageIds: string[]): Promise<[string, [string, Uint8Array | number[]][]][]>;
+export declare function checkIntegrity(): Promise<void>;
+export declare function saveLockFile(): Promise<void>;
+export declare function checkLockFile(): Promise<void>;

package/dist/integrity.js

@@ -0,0 +1,92 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+import { getDependencyType, getRootDir, mainActor } from './mops.js';
+import { resolvePackages } from './resolve-packages.js';
+export async function getFileHashesFromRegistry(packageIds) {
+    let actor = await mainActor();
+    let fileHashesByPackageIds = await actor.getFileHashesByPackageIds(packageIds);
+    return fileHashesByPackageIds;
+}
+export async function checkIntegrity() {
+    let rootDir = getRootDir();
+    let resolvedPackages = await resolvePackages();
+    let packageIds = Object.entries(resolvedPackages)
+        .filter(([_, version]) => getDependencyType(version) === 'mops')
+        .map(([name, version]) => `${name}@${version}`);
+    let fileHashesFromRegistry = await getFileHashesFromRegistry(packageIds);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (let [_packageId, fileHashes] of fileHashesFromRegistry) {
+        for (let [fileId, hash] of fileHashes) {
+            let remoteHash = new Uint8Array(hash);
+            let localData = fs.readFileSync(path.join(rootDir, '.mops', fileId));
+            let localHash = await sha256(localData);
+            if (bytesToHex(localHash) !== bytesToHex(remoteHash)) {
+                console.error('Integrity check failed.');
+                console.error(`Mismatched hash for ${fileId}: ${bytesToHex(localHash)} vs ${bytesToHex(remoteHash)}`);
+                process.exit(1);
+            }
+        }
+    }
+}
+export async function saveLockFile() {
+    let rootDir = getRootDir();
+    let resolvedPackages = await resolvePackages();
+    let packageIds = Object.entries(resolvedPackages)
+        .filter(([_, version]) => getDependencyType(version) === 'mops')
+        .map(([name, version]) => `${name}@${version}`);
+    let fileHashes = await getFileHashesFromRegistry(packageIds);
+    let lockFileJson = {
+        version: 1,
+        hashes: fileHashes.reduce((acc, [packageId, fileHashes]) => {
+            acc[packageId] = fileHashes.reduce((acc, [fileId, hash]) => {
+                acc[fileId] = bytesToHex(new Uint8Array(hash));
+                return acc;
+            }, {});
+            return acc;
+        }, {}),
+    };
+    fs.writeFileSync(rootDir + '/mops-lock.json', JSON.stringify(lockFileJson, null, 2));
+}
+export async function checkLockFile() {
+    let rootDir = getRootDir();
+    let resolvedPackages = await resolvePackages();
+    let packageIds = Object.entries(resolvedPackages)
+        .filter(([_name, version]) => getDependencyType(version) === 'mops')
+        .map(([name, version]) => `${name}@${version}`);
+    let fileHashesFromRegistry = await getFileHashesFromRegistry(packageIds);
+    let lockFileJson = JSON.parse(fs.readFileSync(rootDir + '/mops-lock.json').toString());
+    if (lockFileJson.version !== 1) {
+        console.error(`Invalid lock file version: ${lockFileJson.version}`);
+        process.exit(1);
+    }
+    // if (lockFileJson.packageIds.length !== packageIds.length) {
+    // 	console.error(`Mismatched packageIds: ${JSON.stringify(lockFileJson.packageIds)} vs ${JSON.stringify(packageIds)}`);
+    // 	process.exit(1);
+    // }
+    // for (let i = 0; i < packageIds.length; i++) {
+    // 	if (lockFileJson.packageIds[i] !== packageIds[i]) {
+    // 		console.error(`Mismatched packageIds: ${JSON.stringify(lockFileJson.packageIds)} vs ${JSON.stringify(packageIds)}`);
+    // 		process.exit(1);
+    // 	}
+    // }
+    for (let [packageId, fileHashes] of fileHashesFromRegistry) {
+        let hashes = lockFileJson.hashes[packageId];
+        if (!hashes) {
+            console.error(`Missing packageId ${packageId} in lock file`);
+            process.exit(1);
+        }
+        for (let [fileId, hash] of fileHashes) {
+            let lockFileHash = hashes[fileId];
+            if (!lockFileHash) {
+                console.error(`Missing fileId ${fileId} in lock file`);
+                process.exit(1);
+            }
+            if (lockFileHash !== bytesToHex(new Uint8Array(hash))) {
+                console.error(`Mismatched hash for ${fileId}: ${lockFileHash} vs ${bytesToHex(new Uint8Array(hash))}`);
+                process.exit(1);
+            }
+        }
+    }
+}

package/dist/mops.d.ts

@@ -21,10 +21,12 @@ export declare function checkConfigFile(): boolean;
 export declare function progressBar(step: number, total: number): string;
 export declare function getHighestVersion(pkgName: string): Promise<import("./declarations/main/main.did.js").Result_5>;
 export declare function parseGithubURL(href: string): {
-    org: string | undefined;
-    gitName: string | undefined;
+    org: string;
+    gitName: string;
     branch: string;
+    commitHash: string;
 };
+export declare function getGithubCommit(repo: string, ref: string): Promise<any>;
 export declare function getDependencyType(version: string): "mops" | "github" | "local";
 export declare function readConfig(configFile?: string): Config;
 export declare function writeConfig(config: Config, configFile?: string): void;

package/dist/mops.js

@@ -104,7 +104,7 @@ export let getIdentity = async () => {
     let identityPemEncrypted = path.resolve(globalConfigDir, 'identity.pem.encrypted');
     if (fs.existsSync(identityPemEncrypted)) {
         let res = await prompts({
-            type: 'password',
+            type: 'invisible',
             name: 'value',
             message: 'Enter password:'
         });
@@ -179,12 +179,26 @@ export async function getHighestVersion(pkgName) {
 }
 export function parseGithubURL(href) {
     const url = new URL(href);
-    const branch = url.hash?.substring(1) || 'master';
+    let branchAndSha = url.hash?.substring(1).split('@');
+    let branch = branchAndSha[0] || 'master';
+    let commitHash = branchAndSha[1] || '';
     let [org, gitName] = url.pathname.split('/').filter(path => !!path);
+    org = org || '';
+    gitName = gitName || '';
     if (gitName?.endsWith('.git')) {
         gitName = gitName.substring(0, gitName.length - 4);
     }
-    return { org, gitName, branch };
+    return { org, gitName, branch, commitHash };
+}
+export async function getGithubCommit(repo, ref) {
+    let res = await fetch(`https://api.github.com/repos/${repo}/commits/${ref}`);
+    let json = await res.json();
+    // try on main branch
+    if (json.message && ref === 'master') {
+        res = await fetch(`https://api.github.com/repos/${repo}/commits/main`);
+        json = await res.json();
+    }
+    return json;
 }
 export function getDependencyType(version) {
     if (!version || typeof version !== 'string') {
@@ -244,8 +258,8 @@ export function formatDir(name, version) {
     return path.join(getRootDir(), '.mops', `${name}@${version}`);
 }
 export function formatGithubDir(name, repo) {
-    const { branch } = parseGithubURL(repo);
-    return path.join(getRootDir(), '.mops/_github', `${name}@${branch}`);
+    const { branch, commitHash } = parseGithubURL(repo);
+    return path.join(getRootDir(), '.mops/_github', `${name}#${branch}` + (commitHash ? `@${commitHash}` : ''));
 }
 export function readDfxJson() {
     let dir = process.cwd();

package/dist/package.json

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

package/dist/vessel.js

@@ -59,8 +59,8 @@ export const readVesselConfig = async (dir, { cache = true } = {}) => {
     return config;
 };
 export const downloadFromGithub = async (repo, dest, onProgress) => {
-    const { branch, org, gitName } = parseGithubURL(repo);
-    const zipFile = `https://github.com/${org}/${gitName}/archive/${branch}.zip`;
+    const { branch, org, gitName, commitHash } = parseGithubURL(repo);
+    const zipFile = `https://github.com/${org}/${gitName}/archive/${commitHash || branch}.zip`;
     const readStream = got.stream(zipFile);
     const promise = new Promise((resolve, reject) => {
         readStream.on('error', (err) => {
@@ -71,7 +71,7 @@ export const downloadFromGithub = async (repo, dest, onProgress) => {
         });
         readStream.on('response', (response) => {
             if (response.headers.age > 3600) {
-                console.log(chalk.red('Error: ') + 'Failure - response too old');
+                console.error(chalk.red('Error: ') + 'Failure - response too old');
                 readStream.destroy(); // Destroy the stream to prevent hanging resources.
                 reject();
                 return;
@@ -79,7 +79,7 @@ export const downloadFromGithub = async (repo, dest, onProgress) => {
             // Prevent `onError` being called twice.
             readStream.off('error', reject);
             const tmpDir = path.resolve(process.cwd(), '.mops/_tmp/');
-            const tmpFile = path.resolve(tmpDir, `${gitName}@${branch}.zip`);
+            const tmpFile = path.resolve(tmpDir, `${gitName}@${commitHash || branch}.zip`);
             try {
                 mkdirSync(tmpDir, { recursive: true });
                 pipeline(readStream, createWriteStream(tmpFile), (err) => {
@@ -114,20 +114,20 @@ export const downloadFromGithub = async (repo, dest, onProgress) => {
     return promise;
 };
 export const installFromGithub = async (name, repo, { verbose = false, dep = false, silent = false } = {}) => {
-    const { branch } = parseGithubURL(repo);
-    const dir = formatGithubDir(name, repo);
-    const cacheName = `github_${name}@${branch}`;
+    let { branch, commitHash } = parseGithubURL(repo);
+    let dir = formatGithubDir(name, repo);
+    let cacheName = `_github/${name}#${branch}` + (commitHash ? `@${commitHash}` : '');
     if (existsSync(dir)) {
-        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} (already installed) from Github`);
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (local cache) from Github`);
     }
     else if (isCached(cacheName)) {
         await copyCache(cacheName, dir);
-        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} (cache) from Github`);
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (global cache) from Github`);
     }
     else {
         mkdirSync(dir, { recursive: true });
         let progress = (step, total) => {
-            silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} ${progressBar(step, total)}`);
+            silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} ${progressBar(step, total)}`);
         };
         progress(0, 2 * (1024 ** 2));
         try {

package/mops.ts

@@ -121,7 +121,7 @@ export let getIdentity = async (): Promise<Identity | undefined> => {
 	let identityPemEncrypted = path.resolve(globalConfigDir, 'identity.pem.encrypted');
 	if (fs.existsSync(identityPemEncrypted)) {
 		let res = await prompts({
-			type: 'password',
+			type: 'invisible',
 			name: 'value',
 			message: 'Enter password:'
 		});
@@ -210,15 +210,29 @@ export async function getHighestVersion(pkgName: string) {
 
 export function parseGithubURL(href: string) {
 	const url = new URL(href);
-	const branch =  url.hash?.substring(1) || 'master';
-
+	let branchAndSha = url.hash?.substring(1).split('@');
+	let branch = branchAndSha[0] || 'master';
+	let commitHash = branchAndSha[1] || '';
 	let [org, gitName] = url.pathname.split('/').filter(path => !!path);
+	org = org || '';
+	gitName = gitName || '';
 
 	if (gitName?.endsWith('.git')) {
 		gitName = gitName.substring(0, gitName.length - 4);
 	}
+	return {org, gitName, branch, commitHash};
+}
 
-	return {org, gitName, branch};
+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();
+
+	// try on main branch
+	if (json.message && ref === 'master') {
+		res = await fetch(`https://api.github.com/repos/${repo}/commits/main`);
+		json = await res.json();
+	}
+	return json;
 }
 
 export function getDependencyType(version: string) {
@@ -289,8 +303,8 @@ export function formatDir(name: string, version: string) {
 }
 
 export function formatGithubDir(name: string, repo: string) {
-	const {branch} = parseGithubURL(repo);
-	return path.join(getRootDir(), '.mops/_github', `${name}@${branch}`);
+	const {branch, commitHash} = parseGithubURL(repo);
+	return path.join(getRootDir(), '.mops/_github', `${name}#${branch}` + (commitHash ? `@${commitHash}` : ''));
 }
 
 export function readDfxJson(): any {

package/package.json

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

package/vessel.ts

@@ -83,9 +83,9 @@ export const readVesselConfig = async (dir: string, {cache = true} = {}): Promis
 };
 
 export const downloadFromGithub = async (repo: string, dest: string, onProgress: any) => {
-	const {branch, org, gitName} = parseGithubURL(repo);
+	const {branch, org, gitName, commitHash} = parseGithubURL(repo);
 
-	const zipFile = `https://github.com/${org}/${gitName}/archive/${branch}.zip`;
+	const zipFile = `https://github.com/${org}/${gitName}/archive/${commitHash || branch}.zip`;
 	const readStream = got.stream(zipFile);
 
 	const promise = new Promise((resolve, reject) => {
@@ -99,7 +99,7 @@ export const downloadFromGithub = async (repo: string, dest: string, onProgress:
 
 		readStream.on('response', (response) => {
 			if (response.headers.age > 3600) {
-				console.log(chalk.red('Error: ') +  'Failure - response too old');
+				console.error(chalk.red('Error: ') +  'Failure - response too old');
 				readStream.destroy(); // Destroy the stream to prevent hanging resources.
 				reject();
 				return;
@@ -108,7 +108,7 @@ export const downloadFromGithub = async (repo: string, dest: string, onProgress:
 			// Prevent `onError` being called twice.
 			readStream.off('error', reject);
 			const tmpDir = path.resolve(process.cwd(), '.mops/_tmp/');
-			const tmpFile = path.resolve(tmpDir, `${gitName}@${branch}.zip`);
+			const tmpFile = path.resolve(tmpDir, `${gitName}@${commitHash || branch}.zip`);
 
 			try {
 				mkdirSync(tmpDir, {recursive: true});
@@ -147,22 +147,22 @@ export const downloadFromGithub = async (repo: string, dest: string, onProgress:
 };
 
 export const installFromGithub = async (name: string, repo: string, {verbose = false, dep = false, silent = false} = {}) => {
-	const {branch} = parseGithubURL(repo);
-	const dir = formatGithubDir(name, repo);
-	const cacheName = `github_${name}@${branch}`;
+	let {branch, commitHash} = parseGithubURL(repo);
+	let dir = formatGithubDir(name, repo);
+	let cacheName = `_github/${name}#${branch}` + (commitHash ? `@${commitHash}` : '');
 
 	if (existsSync(dir)) {
-		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} (already installed) from Github`);
+		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (local cache) from Github`);
 	}
 	else if (isCached(cacheName)) {
 		await copyCache(cacheName, dir);
-		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} (cache) from Github`);
+		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (global cache) from Github`);
 	}
 	else {
 		mkdirSync(dir, {recursive: true});
 
 		let progress = (step: number, total: number) => {
-			silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} ${progressBar(step, total)}`);
+			silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} ${progressBar(step, total)}`);
 		};
 
 		progress(0, 2 * (1024 ** 2));