ic-mops 0.27.3 → 0.28.0

package/commands/add.ts

@@ -4,6 +4,7 @@ import logUpdate from 'log-update';
 import {checkConfigFile, getHighestVersion, parseGithubURL, readConfig, writeConfig} from '../mops.js';
 import {installFromGithub} from '../vessel.js';
 import {install} from './install.js';
+import {notifyInstalls} from '../notify-installs.js';
 
 export async function add(name: string, {verbose = false, dev = false} = {}) {
 	if (!checkConfigFile()) {
@@ -66,14 +67,17 @@ export async function add(name: string, {verbose = false, dev = false} = {}) {
 		};
 	}
 
+	let installedPackages = {};
+
 	if (pkgDetails.repo) {
 		await installFromGithub(pkgDetails.name, pkgDetails.repo, {verbose: verbose});
 	}
 	else if (!pkgDetails.path) {
-		let ok = await install(pkgDetails.name, pkgDetails.version, {verbose: verbose});
-		if (!ok) {
+		let res = await install(pkgDetails.name, pkgDetails.version, {verbose: verbose});
+		if (res === false) {
 			return;
 		}
+		installedPackages = {...installedPackages, ...res};
 	}
 
 	const depsProp = dev ? 'dev-dependencies' : 'dependencies';
@@ -84,7 +88,9 @@ export async function add(name: string, {verbose = false, dev = false} = {}) {
 	else {
 		throw Error(`Invalid config file: [${depsProp}] not found`);
 	}
+
 	writeConfig(config);
+	await notifyInstalls(Object.keys(installedPackages));
 
 	logUpdate.clear();
 	console.log(chalk.green('Package installed ') + `${pkgDetails.name} = "${pkgDetails.repo || pkgDetails.path || pkgDetails.version}"`);

package/commands/install-all.ts

@@ -3,6 +3,7 @@ import logUpdate from 'log-update';
 import {checkConfigFile, readConfig} from '../mops.js';
 import {install} from './install.js';
 import {installFromGithub} from '../vessel.js';
+import {notifyInstalls} from '../notify-installs.js';
 
 export async function installAll({verbose = false, silent = false} = {}) {
 	if (!checkConfigFile()) {
@@ -13,19 +14,23 @@ export async function installAll({verbose = false, silent = false} = {}) {
 	let deps = Object.values(config.dependencies || {});
 	let devDeps = Object.values(config['dev-dependencies'] || {});
 	let allDeps = [...deps, ...devDeps];
+	let installedPackages = {};
 
 	for (let {name, repo, path, version} of allDeps) {
 		if (repo) {
 			await installFromGithub(name, repo, {verbose, silent});
 		}
 		else if (!path) {
-			let ok = await install(name, version, {verbose, silent});
-			if (!ok) {
+			let res = await install(name, version, {verbose, silent});
+			if (res === false) {
 				return;
 			}
+			installedPackages = {...installedPackages, ...res};
 		}
 	}
 
+	await notifyInstalls(Object.keys(installedPackages));
+
 	if (!silent) {
 		logUpdate.clear();
 		console.log(chalk.green('All packages installed'));

package/commands/install.ts

@@ -7,7 +7,7 @@ import {parallel} from '../parallel.js';
 import {installFromGithub} from '../vessel.js';
 import {addCache, copyCache, isCached} from '../cache.js';
 
-export async function install(pkg: string, version = '', {verbose = false, silent = false, dep = false} = {}) {
+export async function install(pkg: string, version = '', {verbose = false, silent = false, dep = false} = {}): Promise<Record<string, string> | false> {
 	if (!checkConfigFile()) {
 		return false;
 	}
@@ -32,14 +32,15 @@ export async function install(pkg: string, version = '', {verbose = false, silen
 
 	let dir = formatDir(pkg, version);
 	let actor = await mainActor();
+	let alreadyInstalled = false;
 
 	// already installed
 	if (fs.existsSync(dir)) {
 		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (already installed)`);
+		alreadyInstalled = true;
 	}
 	// copy from cache
 	else if (isCached(`${pkg}@${version}`)) {
-		actor.notifyInstall(pkg, version);
 		await copyCache(`${pkg}@${version}`, dir);
 		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (cache)`);
 	}
@@ -65,8 +66,6 @@ export async function install(pkg: string, version = '', {verbose = false, silen
 
 		let storage = await storageActor(packageDetails.publication.storage);
 
-		actor.notifyInstall(pkg, version);
-
 		// download files
 		let filesData = new Map;
 		let threads = 16;
@@ -118,17 +117,28 @@ export async function install(pkg: string, version = '', {verbose = false, silen
 	let ok = true;
 	let config = readConfig(path.join(dir, 'mops.toml'));
 	let deps = Object.values(config.dependencies || {});
+	let installedDeps = {};
 	for (const {name, repo, version} of deps) {
 		if (repo) {
 			await installFromGithub(name, repo, {silent, verbose});
 		}
 		else {
 			let res = await install(name, version, {silent, verbose});
-			if (!res) {
+			if (res) {
+				installedDeps = {...installedDeps, ...res};
+			}
+			else {
 				ok = false;
 			}
 		}
 	}
 
-	return ok;
+	if (!alreadyInstalled) {
+		installedDeps = {...installedDeps, [pkg]: version};
+	}
+
+	if (ok) {
+		return installedDeps;
+	}
+	return false;
 }

package/commands/publish.ts

@@ -233,6 +233,14 @@ export async function publish(options: {docs?: boolean, test?: boolean} = {}) {
 	// parse changelog
 	console.log('Parsing CHANGELOG.md...');
 	let changelog = parseChangelog(config.package.version);
+	if (!changelog && config.package.repository) {
+		console.log('Fetching release notes from GitHub...');
+		changelog = await fetchGitHubReleaseNotes(config.package.repository, config.package.version);
+	}
+	if (changelog) {
+		console.log('Changelog:');
+		console.log(chalk.gray(changelog));
+	}
 
 	// test
 	let reporter = new SilentReporter;
@@ -342,17 +350,31 @@ function parseChangelog(version: string): string {
 	let str = fs.readFileSync(changelogFile, 'utf-8');
 	let changelog = findChangelogEntry(str, version);
 
-	if (changelog) {
-		console.log('Changelog:');
-		console.log(chalk.gray(changelog));
-	}
-	else {
+	if (!changelog) {
 		console.log(chalk.yellow('No changelog entry found'));
 	}
 
 	return changelog || '';
 }
 
+async function fetchGitHubReleaseNotes(repo: string, version: string): Promise<string> {
+	let repoPath = new URL(repo).pathname;
+	let res = await fetch(`https://api.github.com/repos${repoPath}/releases/tags/${version}`);
+	let release = await res.json();
+
+	if (release.message === 'Not Found') {
+		res = await fetch(`https://api.github.com/repos${repoPath}/releases/tags/v${version}`);
+		release = await res.json();
+
+		if (release.message === 'Not Found') {
+			console.log(chalk.yellow(`No GitHub release found with name ${version} or v${version}`));
+			return '';
+		}
+	}
+
+	return release.body;
+}
+
 function findChangelogEntry(changelog: string, version: string): string {
 	let tree = fromMarkdown(changelog);
 	let found = false;

package/commands/sources.ts

@@ -1,9 +1,7 @@
 import path from 'node:path';
 import fs from 'node:fs';
-import chalk from 'chalk';
-import {checkConfigFile, formatDir, formatGithubDir, getRootDir, parseGithubURL, readConfig} from '../mops.js';
-import {VesselConfig, readVesselConfig} from '../vessel.js';
-import {Config, Dependency} from '../types.js';
+import {checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConfig} from '../mops.js';
+import {resolvePackages} from '../resolve-packages.js';
 
 // TODO: resolve conflicts
 export async function sources({verbose = false} = {}) {
@@ -11,118 +9,21 @@ export async function sources({verbose = false} = {}) {
 		return [];
 	}
 
-	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];
-		if (ap[0] - bp[0]) {
-			return Math.sign(ap[0] - bp[0]);
-		}
-		if (ap[0] === bp[0] && ap[1] - bp[1]) {
-			return Math.sign(ap[1] - bp[1]);
-		}
-		if (ap[0] === bp[0] && ap[1] === bp[1] && ap[2] - bp[2]) {
-			return Math.sign(ap[2] - bp[2]);
-		}
-		return 0;
-	};
-
-	const gitVerRegex = new RegExp(/v(\d{1,2}\.\d{1,2}\.\d{1,2})(-.*)?$/);
-
-	const compareGitVersions = (repoA: string, repoB: string) => {
-		const {branch: a} = parseGithubURL(repoA);
-		const {branch: b} = parseGithubURL(repoB);
-
-		if (gitVerRegex.test(a) && gitVerRegex.test(b)) {
-			return compareVersions(a.substring(1) , b.substring(1));
-		}
-		else if (!gitVerRegex.test(a)) {
-			return -1;
-		}
-		else {
-			return 1;
-		}
-	};
-
-	let collectDeps = async (config: Config | VesselConfig, isRoot = false) => {
-		let allDeps = [...Object.values(config.dependencies || {})];
-		if (isRoot) {
-			allDeps = [...allDeps, ...Object.values(config['dev-dependencies'] || {})];
-		}
-		for (const pkgDetails of allDeps) {
-			const {name, repo, version} = pkgDetails;
-
-			// take root dep version or bigger one
-			if (
-				isRoot
-				|| !packages[name]
-				|| !packages[name]?.isRoot
-				&& (
-					repo && packages[name]?.repo && compareGitVersions(packages[name]?.repo || '', repo) === -1
-					|| compareVersions(packages[name]?.version, version) === -1)
-			) {
-				packages[name] = {
-					...pkgDetails,
-					isRoot,
-				};
-			}
-
-			let nestedConfig;
-
-			if (repo) {
-				const dir = formatGithubDir(name, repo);
-				nestedConfig = await readVesselConfig(dir) || {};
-			}
-			else if (!pkgDetails.path && version) {
-				const file = formatDir(name, version) + '/mops.toml';
-				nestedConfig = readConfig(file);
-			}
-
-			if (nestedConfig && !pkgDetails.path) {
-				await collectDeps(nestedConfig);
-			}
-
-			if (!versions[name]) {
-				versions[name] = [];
-			}
-
-			if (repo) {
-				const {branch} = parseGithubURL(repo);
-				versions[name]?.push(branch);
-			}
-			else if (version) {
-				versions[name]?.push(version);
-			}
-		}
-	};
-
-	let config = readConfig();
-	await collectDeps(config, true);
-
-	// show conflicts
-	if (verbose) {
-		for (let [dep, vers] of Object.entries(versions)) {
-			if (vers.length > 1) {
-				console.log(chalk.yellow('WARN:'), `Conflicting package versions "${dep}" - ${vers.join(', ')}`);
-			}
-		}
-	}
+	let resolvedPackages = await resolvePackages({verbose});
 
 	// sources
-	let rootDir = getRootDir();
-	return Object.entries(packages).map(([name, pkg]) => {
+	return Object.entries(resolvedPackages).map(([name, version]) => {
+		let depType = getDependencyType(version);
+
 		let pkgDir;
-		if (pkg.path) {
-			pkgDir = path.relative(process.cwd(), path.resolve(rootDir, pkg.path));
-			pkgDir = pkgDir.replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
+		if (depType === 'local') {
+			pkgDir = path.relative(process.cwd(), version);
 		}
-		else if (pkg.repo) {
-			pkgDir = path.relative(process.cwd(), formatGithubDir(name, pkg.repo));
+		else if (depType === 'github') {
+			pkgDir = path.relative(process.cwd(), formatGithubDir(name, version));
 		}
-		else if (pkg.version) {
-			pkgDir = path.relative(process.cwd(), formatDir(name, pkg.version));
+		else if (depType === 'mops') {
+			pkgDir = path.relative(process.cwd(), formatDir(name, version));
 		}
 		else {
 			return;
@@ -139,7 +40,7 @@ export async function sources({verbose = false} = {}) {
 		}
 
 		// use pkgDir if baseDir doesn't exist for local packages
-		if (pkg.path && !fs.existsSync(pkgBaseDir)) {
+		if (depType === 'local' && !fs.existsSync(pkgBaseDir)) {
 			pkgBaseDir = pkgDir;
 		}
 

package/declarations/main/main.did

@@ -301,6 +301,10 @@ service : {
   getTotalPackages: () -> (nat) query;
   getUser: (principal) -> (opt User__1) query;
   notifyInstall: (PackageName__1, PackageVersion) -> () oneway;
+  notifyInstalls: (vec record {
+                         PackageName__1;
+                         PackageVersion;
+                       }) -> () oneway;
   restore: (nat, nat) -> ();
   search: (Text, opt nat, opt nat) -> (vec PackageSummary, PageCount) query;
   setUserProp: (text, text) -> (Result_3);

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

@@ -247,6 +247,10 @@ export interface _SERVICE {
   'getTotalPackages' : ActorMethod<[], bigint>,
   'getUser' : ActorMethod<[Principal], [] | [User__1]>,
   'notifyInstall' : ActorMethod<[PackageName__1, PackageVersion], undefined>,
+  'notifyInstalls' : ActorMethod<
+    [Array<[PackageName__1, PackageVersion]>],
+    undefined
+  >,
   'restore' : ActorMethod<[bigint, bigint], undefined>,
   'search' : ActorMethod<
     [Text, [] | [bigint], [] | [bigint]],

package/declarations/main/main.did.js

@@ -275,6 +275,11 @@ export const idlFactory = ({ IDL }) => {
         [],
         ['oneway'],
       ),
+    'notifyInstalls' : IDL.Func(
+        [IDL.Vec(IDL.Tuple(PackageName__1, PackageVersion))],
+        [],
+        ['oneway'],
+      ),
     'restore' : IDL.Func([IDL.Nat, IDL.Nat], [], []),
     'search' : IDL.Func(
         [Text, IDL.Opt(IDL.Nat), IDL.Opt(IDL.Nat)],

package/dist/commands/add.js

@@ -4,6 +4,7 @@ import logUpdate from 'log-update';
 import { checkConfigFile, getHighestVersion, parseGithubURL, readConfig, writeConfig } from '../mops.js';
 import { installFromGithub } from '../vessel.js';
 import { install } from './install.js';
+import { notifyInstalls } from '../notify-installs.js';
 export async function add(name, { verbose = false, dev = false } = {}) {
     if (!checkConfigFile()) {
         return;
@@ -59,14 +60,16 @@ export async function add(name, { verbose = false, dev = false } = {}) {
             version: ver,
         };
     }
+    let installedPackages = {};
     if (pkgDetails.repo) {
         await installFromGithub(pkgDetails.name, pkgDetails.repo, { verbose: verbose });
     }
     else if (!pkgDetails.path) {
-        let ok = await install(pkgDetails.name, pkgDetails.version, { verbose: verbose });
-        if (!ok) {
+        let res = await install(pkgDetails.name, pkgDetails.version, { verbose: verbose });
+        if (res === false) {
             return;
         }
+        installedPackages = { ...installedPackages, ...res };
     }
     const depsProp = dev ? 'dev-dependencies' : 'dependencies';
     let deps = config[depsProp];
@@ -77,6 +80,7 @@ export async function add(name, { verbose = false, dev = false } = {}) {
         throw Error(`Invalid config file: [${depsProp}] not found`);
     }
     writeConfig(config);
+    await notifyInstalls(Object.keys(installedPackages));
     logUpdate.clear();
     console.log(chalk.green('Package installed ') + `${pkgDetails.name} = "${pkgDetails.repo || pkgDetails.path || pkgDetails.version}"`);
 }

package/dist/commands/install-all.js

@@ -3,6 +3,7 @@ import logUpdate from 'log-update';
 import { checkConfigFile, readConfig } from '../mops.js';
 import { install } from './install.js';
 import { installFromGithub } from '../vessel.js';
+import { notifyInstalls } from '../notify-installs.js';
 export async function installAll({ verbose = false, silent = false } = {}) {
     if (!checkConfigFile()) {
         return;
@@ -11,17 +12,20 @@ export async function installAll({ verbose = false, silent = false } = {}) {
     let deps = Object.values(config.dependencies || {});
     let devDeps = Object.values(config['dev-dependencies'] || {});
     let allDeps = [...deps, ...devDeps];
+    let installedPackages = {};
     for (let { name, repo, path, version } of allDeps) {
         if (repo) {
             await installFromGithub(name, repo, { verbose, silent });
         }
         else if (!path) {
-            let ok = await install(name, version, { verbose, silent });
-            if (!ok) {
+            let res = await install(name, version, { verbose, silent });
+            if (res === false) {
                 return;
             }
+            installedPackages = { ...installedPackages, ...res };
         }
     }
+    await notifyInstalls(Object.keys(installedPackages));
     if (!silent) {
         logUpdate.clear();
         console.log(chalk.green('All packages installed'));

package/dist/commands/install.d.ts

@@ -2,4 +2,4 @@ export declare function install(pkg: string, version?: string, { verbose, silent
     verbose?: boolean | undefined;
     silent?: boolean | undefined;
     dep?: boolean | undefined;
-}): Promise<boolean>;
+}): Promise<Record<string, string> | false>;

package/dist/commands/install.js

@@ -28,13 +28,14 @@ export async function install(pkg, version = '', { verbose = false, silent = fal
     }
     let dir = formatDir(pkg, version);
     let actor = await mainActor();
+    let alreadyInstalled = false;
     // already installed
     if (fs.existsSync(dir)) {
         silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (already installed)`);
+        alreadyInstalled = true;
     }
     // copy from cache
     else if (isCached(`${pkg}@${version}`)) {
-        actor.notifyInstall(pkg, version);
         await copyCache(`${pkg}@${version}`, dir);
         silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (cache)`);
     }
@@ -56,7 +57,6 @@ export async function install(pkg, version = '', { verbose = false, silent = fal
         let filesIds = filesIdsRes.ok;
         total = filesIds.length + 2;
         let storage = await storageActor(packageDetails.publication.storage);
-        actor.notifyInstall(pkg, version);
         // download files
         let filesData = new Map;
         let threads = 16;
@@ -100,16 +100,26 @@ export async function install(pkg, version = '', { verbose = false, silent = fal
     let ok = true;
     let config = readConfig(path.join(dir, 'mops.toml'));
     let deps = Object.values(config.dependencies || {});
+    let installedDeps = {};
     for (const { name, repo, version } of deps) {
         if (repo) {
             await installFromGithub(name, repo, { silent, verbose });
         }
         else {
             let res = await install(name, version, { silent, verbose });
-            if (!res) {
+            if (res) {
+                installedDeps = { ...installedDeps, ...res };
+            }
+            else {
                 ok = false;
             }
         }
     }
-    return ok;
+    if (!alreadyInstalled) {
+        installedDeps = { ...installedDeps, [pkg]: version };
+    }
+    if (ok) {
+        return installedDeps;
+    }
+    return false;
 }

package/dist/commands/publish.js

@@ -208,6 +208,14 @@ export async function publish(options = {}) {
     // parse changelog
     console.log('Parsing CHANGELOG.md...');
     let changelog = parseChangelog(config.package.version);
+    if (!changelog && config.package.repository) {
+        console.log('Fetching release notes from GitHub...');
+        changelog = await fetchGitHubReleaseNotes(config.package.repository, config.package.version);
+    }
+    if (changelog) {
+        console.log('Changelog:');
+        console.log(chalk.gray(changelog));
+    }
     // test
     let reporter = new SilentReporter;
     if (options.test) {
@@ -298,15 +306,25 @@ function parseChangelog(version) {
     }
     let str = fs.readFileSync(changelogFile, 'utf-8');
     let changelog = findChangelogEntry(str, version);
-    if (changelog) {
-        console.log('Changelog:');
-        console.log(chalk.gray(changelog));
-    }
-    else {
+    if (!changelog) {
         console.log(chalk.yellow('No changelog entry found'));
     }
     return changelog || '';
 }
+async function fetchGitHubReleaseNotes(repo, version) {
+    let repoPath = new URL(repo).pathname;
+    let res = await fetch(`https://api.github.com/repos${repoPath}/releases/tags/${version}`);
+    let release = await res.json();
+    if (release.message === 'Not Found') {
+        res = await fetch(`https://api.github.com/repos${repoPath}/releases/tags/v${version}`);
+        release = await res.json();
+        if (release.message === 'Not Found') {
+            console.log(chalk.yellow(`No GitHub release found with name ${version} or v${version}`));
+            return '';
+        }
+    }
+    return release.body;
+}
 function findChangelogEntry(changelog, version) {
     let tree = fromMarkdown(changelog);
     let found = false;

package/dist/commands/sources.js

@@ -1,108 +1,25 @@
 import path from 'node:path';
 import fs from 'node:fs';
-import chalk from 'chalk';
-import { checkConfigFile, formatDir, formatGithubDir, getRootDir, parseGithubURL, readConfig } from '../mops.js';
-import { readVesselConfig } from '../vessel.js';
+import { checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConfig } from '../mops.js';
+import { resolvePackages } from '../resolve-packages.js';
 // TODO: resolve conflicts
 export async function sources({ verbose = false } = {}) {
     if (!checkConfigFile()) {
         return [];
     }
-    let packages = {};
-    let versions = {};
-    let compareVersions = (a = '0.0.0', b = '0.0.0') => {
-        let ap = a.split('.').map((x) => parseInt(x));
-        let bp = b.split('.').map((x) => parseInt(x));
-        if (ap[0] - bp[0]) {
-            return Math.sign(ap[0] - bp[0]);
-        }
-        if (ap[0] === bp[0] && ap[1] - bp[1]) {
-            return Math.sign(ap[1] - bp[1]);
-        }
-        if (ap[0] === bp[0] && ap[1] === bp[1] && ap[2] - bp[2]) {
-            return Math.sign(ap[2] - bp[2]);
-        }
-        return 0;
-    };
-    const gitVerRegex = new RegExp(/v(\d{1,2}\.\d{1,2}\.\d{1,2})(-.*)?$/);
-    const compareGitVersions = (repoA, repoB) => {
-        const { branch: a } = parseGithubURL(repoA);
-        const { branch: b } = parseGithubURL(repoB);
-        if (gitVerRegex.test(a) && gitVerRegex.test(b)) {
-            return compareVersions(a.substring(1), b.substring(1));
-        }
-        else if (!gitVerRegex.test(a)) {
-            return -1;
-        }
-        else {
-            return 1;
-        }
-    };
-    let collectDeps = async (config, isRoot = false) => {
-        let allDeps = [...Object.values(config.dependencies || {})];
-        if (isRoot) {
-            allDeps = [...allDeps, ...Object.values(config['dev-dependencies'] || {})];
-        }
-        for (const pkgDetails of allDeps) {
-            const { name, repo, version } = pkgDetails;
-            // take root dep version or bigger one
-            if (isRoot
-                || !packages[name]
-                || !packages[name]?.isRoot
-                    && (repo && packages[name]?.repo && compareGitVersions(packages[name]?.repo || '', repo) === -1
-                        || compareVersions(packages[name]?.version, version) === -1)) {
-                packages[name] = {
-                    ...pkgDetails,
-                    isRoot,
-                };
-            }
-            let nestedConfig;
-            if (repo) {
-                const dir = formatGithubDir(name, repo);
-                nestedConfig = await readVesselConfig(dir) || {};
-            }
-            else if (!pkgDetails.path && version) {
-                const file = formatDir(name, version) + '/mops.toml';
-                nestedConfig = readConfig(file);
-            }
-            if (nestedConfig && !pkgDetails.path) {
-                await collectDeps(nestedConfig);
-            }
-            if (!versions[name]) {
-                versions[name] = [];
-            }
-            if (repo) {
-                const { branch } = parseGithubURL(repo);
-                versions[name]?.push(branch);
-            }
-            else if (version) {
-                versions[name]?.push(version);
-            }
-        }
-    };
-    let config = readConfig();
-    await collectDeps(config, true);
-    // show conflicts
-    if (verbose) {
-        for (let [dep, vers] of Object.entries(versions)) {
-            if (vers.length > 1) {
-                console.log(chalk.yellow('WARN:'), `Conflicting package versions "${dep}" - ${vers.join(', ')}`);
-            }
-        }
-    }
+    let resolvedPackages = await resolvePackages({ verbose });
     // sources
-    let rootDir = getRootDir();
-    return Object.entries(packages).map(([name, pkg]) => {
+    return Object.entries(resolvedPackages).map(([name, version]) => {
+        let depType = getDependencyType(version);
         let pkgDir;
-        if (pkg.path) {
-            pkgDir = path.relative(process.cwd(), path.resolve(rootDir, pkg.path));
-            pkgDir = pkgDir.replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
+        if (depType === 'local') {
+            pkgDir = path.relative(process.cwd(), version);
         }
-        else if (pkg.repo) {
-            pkgDir = path.relative(process.cwd(), formatGithubDir(name, pkg.repo));
+        else if (depType === 'github') {
+            pkgDir = path.relative(process.cwd(), formatGithubDir(name, version));
         }
-        else if (pkg.version) {
-            pkgDir = path.relative(process.cwd(), formatDir(name, pkg.version));
+        else if (depType === 'mops') {
+            pkgDir = path.relative(process.cwd(), formatDir(name, version));
         }
         else {
             return;
@@ -117,7 +34,7 @@ export async function sources({ verbose = false } = {}) {
             pkgBaseDir = path.join(pkgDir, 'src');
         }
         // use pkgDir if baseDir doesn't exist for local packages
-        if (pkg.path && !fs.existsSync(pkgBaseDir)) {
+        if (depType === 'local' && !fs.existsSync(pkgBaseDir)) {
             pkgBaseDir = pkgDir;
         }
         return `--package ${name} ${pkgBaseDir}`;

package/dist/declarations/main/main.did

@@ -301,6 +301,10 @@ service : {
   getTotalPackages: () -> (nat) query;
   getUser: (principal) -> (opt User__1) query;
   notifyInstall: (PackageName__1, PackageVersion) -> () oneway;
+  notifyInstalls: (vec record {
+                         PackageName__1;
+                         PackageVersion;
+                       }) -> () oneway;
   restore: (nat, nat) -> ();
   search: (Text, opt nat, opt nat) -> (vec PackageSummary, PageCount) query;
   setUserProp: (text, text) -> (Result_3);

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

@@ -247,6 +247,10 @@ export interface _SERVICE {
   'getTotalPackages' : ActorMethod<[], bigint>,
   'getUser' : ActorMethod<[Principal], [] | [User__1]>,
   'notifyInstall' : ActorMethod<[PackageName__1, PackageVersion], undefined>,
+  'notifyInstalls' : ActorMethod<
+    [Array<[PackageName__1, PackageVersion]>],
+    undefined
+  >,
   'restore' : ActorMethod<[bigint, bigint], undefined>,
   'search' : ActorMethod<
     [Text, [] | [bigint], [] | [bigint]],

package/dist/declarations/main/main.did.js

@@ -275,6 +275,11 @@ export const idlFactory = ({ IDL }) => {
         [],
         ['oneway'],
       ),
+    'notifyInstalls' : IDL.Func(
+        [IDL.Vec(IDL.Tuple(PackageName__1, PackageVersion))],
+        [],
+        ['oneway'],
+      ),
     'restore' : IDL.Func([IDL.Nat, IDL.Nat], [], []),
     'search' : IDL.Func(
         [Text, IDL.Opt(IDL.Nat), IDL.Opt(IDL.Nat)],

package/dist/mops.d.ts

@@ -25,6 +25,7 @@ export declare function parseGithubURL(href: string): {
     gitName: string | undefined;
     branch: string;
 };
+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;
 export declare function formatDir(name: string, version: string): string;

package/dist/mops.js

@@ -186,6 +186,20 @@ export function parseGithubURL(href) {
     }
     return { org, gitName, branch };
 }
+export function getDependencyType(version) {
+    if (!version || typeof version !== 'string') {
+        throw Error(`Invalid dependency value "${version}"`);
+    }
+    if (version.startsWith('https://github.com/')) {
+        return 'github';
+    }
+    else if (version.match(/^(\.?\.)?\//)) {
+        return 'local';
+    }
+    else {
+        return 'mops';
+    }
+}
 export function readConfig(configFile = getClosestConfigFile()) {
     let text = fs.readFileSync(configFile).toString();
     let toml = TOML.parse(text);
@@ -194,10 +208,11 @@ export function readConfig(configFile = getClosestConfigFile()) {
             if (!data || typeof data !== 'string') {
                 throw Error(`Invalid dependency value ${name} = "${data}"`);
             }
-            if (data.startsWith('https://github.com/')) {
+            let depType = getDependencyType(data);
+            if (depType === 'github') {
                 deps[name] = { name, repo: data, version: '' };
             }
-            else if (data.match(/^(\.?\.)?\//)) {
+            else if (depType === 'local') {
                 deps[name] = { name, repo: '', path: data, version: '' };
             }
             else {

package/dist/notify-installs.d.ts

@@ -0,0 +1 @@
+export declare function notifyInstalls(names: string[]): Promise<void>;

package/dist/notify-installs.js

@@ -0,0 +1,10 @@
+import { mainActor } from './mops.js';
+import { resolvePackages } from './resolve-packages.js';
+export async function notifyInstalls(names) {
+    let resolvedPackages = await resolvePackages();
+    let packages = names.map(name => [name, resolvedPackages[name]]);
+    if (packages.length) {
+        let actor = await mainActor();
+        await actor.notifyInstalls(packages);
+    }
+}

package/dist/package.json

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

package/dist/resolve-packages.d.ts

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

package/dist/resolve-packages.js

@@ -0,0 +1,108 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import { checkConfigFile, formatDir, formatGithubDir, getRootDir, parseGithubURL, readConfig } from './mops.js';
+import { readVesselConfig } from './vessel.js';
+export async function resolvePackages({ verbose = false } = {}) {
+    if (!checkConfigFile()) {
+        return {};
+    }
+    let packages = {};
+    let versions = {};
+    let compareVersions = (a = '0.0.0', b = '0.0.0') => {
+        let ap = a.split('.').map((x) => parseInt(x));
+        let bp = b.split('.').map((x) => parseInt(x));
+        if (ap[0] - bp[0]) {
+            return Math.sign(ap[0] - bp[0]);
+        }
+        if (ap[0] === bp[0] && ap[1] - bp[1]) {
+            return Math.sign(ap[1] - bp[1]);
+        }
+        if (ap[0] === bp[0] && ap[1] === bp[1] && ap[2] - bp[2]) {
+            return Math.sign(ap[2] - bp[2]);
+        }
+        return 0;
+    };
+    const gitVerRegex = new RegExp(/v(\d{1,2}\.\d{1,2}\.\d{1,2})(-.*)?$/);
+    const compareGitVersions = (repoA, repoB) => {
+        const { branch: a } = parseGithubURL(repoA);
+        const { branch: b } = parseGithubURL(repoB);
+        if (gitVerRegex.test(a) && gitVerRegex.test(b)) {
+            return compareVersions(a.substring(1), b.substring(1));
+        }
+        else if (!gitVerRegex.test(a)) {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    };
+    let collectDeps = async (config, isRoot = false) => {
+        let allDeps = [...Object.values(config.dependencies || {})];
+        if (isRoot) {
+            allDeps = [...allDeps, ...Object.values(config['dev-dependencies'] || {})];
+        }
+        for (const pkgDetails of allDeps) {
+            const { name, repo, version } = pkgDetails;
+            // take root dep version or bigger one
+            if (isRoot
+                || !packages[name]
+                || !packages[name]?.isRoot
+                    && (repo && packages[name]?.repo && compareGitVersions(packages[name]?.repo || '', repo) === -1
+                        || compareVersions(packages[name]?.version, version) === -1)) {
+                packages[name] = {
+                    ...pkgDetails,
+                    isRoot,
+                };
+            }
+            let nestedConfig;
+            if (repo) {
+                const dir = formatGithubDir(name, repo);
+                nestedConfig = await readVesselConfig(dir) || {};
+            }
+            else if (!pkgDetails.path && version) {
+                const file = formatDir(name, version) + '/mops.toml';
+                nestedConfig = readConfig(file);
+            }
+            if (nestedConfig && !pkgDetails.path) {
+                await collectDeps(nestedConfig);
+            }
+            if (!versions[name]) {
+                versions[name] = [];
+            }
+            if (repo) {
+                const { branch } = parseGithubURL(repo);
+                versions[name]?.push(branch);
+            }
+            else if (version) {
+                versions[name]?.push(version);
+            }
+        }
+    };
+    let config = readConfig();
+    await collectDeps(config, true);
+    // show conflicts
+    if (verbose) {
+        for (let [dep, vers] of Object.entries(versions)) {
+            if (vers.length > 1) {
+                console.log(chalk.yellow('WARN:'), `Conflicting package versions "${dep}" - ${vers.join(', ')}`);
+            }
+        }
+    }
+    let rootDir = getRootDir();
+    return Object.fromEntries(Object.entries(packages).map(([name, pkg]) => {
+        let version;
+        if (pkg.path) {
+            version = path.resolve(rootDir, pkg.path).replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
+        }
+        else if (pkg.repo) {
+            version = pkg.repo;
+        }
+        else if (pkg.version) {
+            version = pkg.version;
+        }
+        else {
+            return [name, ''];
+        }
+        return [name, version];
+    }).filter(([, version]) => version !== ''));
+}

package/mops.ts

@@ -221,6 +221,21 @@ export function parseGithubURL(href: string) {
 	return {org, gitName, branch};
 }
 
+export function getDependencyType(version: string) {
+	if (!version || typeof version !== 'string') {
+		throw Error(`Invalid dependency value "${version}"`);
+	}
+	if (version.startsWith('https://github.com/')) {
+		return 'github';
+	}
+	else if (version.match(/^(\.?\.)?\//)) {
+		return 'local';
+	}
+	else {
+		return 'mops';
+	}
+}
+
 export function readConfig(configFile = getClosestConfigFile()): Config {
 	let text = fs.readFileSync(configFile).toString();
 	let toml = TOML.parse(text);
@@ -230,10 +245,11 @@ export function readConfig(configFile = getClosestConfigFile()): Config {
 			if (!data || typeof data !== 'string') {
 				throw Error(`Invalid dependency value ${name} = "${data}"`);
 			}
-			if (data.startsWith('https://github.com/')) {
+			let depType = getDependencyType(data);
+			if (depType === 'github') {
 				deps[name] = {name, repo: data, version: ''};
 			}
-			else if (data.match(/^(\.?\.)?\//)) {
+			else if (depType === 'local') {
 				deps[name] = {name, repo: '', path: data, version: ''};
 			}
 			else {

package/notify-installs.ts

@@ -0,0 +1,11 @@
+import {mainActor} from './mops.js';
+import {resolvePackages} from './resolve-packages.js';
+
+export async function notifyInstalls(names: string[]) {
+	let resolvedPackages = await resolvePackages();
+	let packages: [string, string][] = names.map(name => [name, resolvedPackages[name] as string]);
+	if (packages.length) {
+		let actor = await mainActor();
+		await actor.notifyInstalls(packages);
+	}
+}

package/package.json

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

package/resolve-packages.ts

@@ -0,0 +1,131 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import {checkConfigFile, formatDir, formatGithubDir, getRootDir, parseGithubURL, readConfig} from './mops.js';
+import {VesselConfig, readVesselConfig} from './vessel.js';
+import {Config, Dependency} from './types.js';
+
+export async function resolvePackages({verbose = false} = {}): Promise<Record<string, string>> {
+	if (!checkConfigFile()) {
+		return {};
+	}
+
+	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];
+		if (ap[0] - bp[0]) {
+			return Math.sign(ap[0] - bp[0]);
+		}
+		if (ap[0] === bp[0] && ap[1] - bp[1]) {
+			return Math.sign(ap[1] - bp[1]);
+		}
+		if (ap[0] === bp[0] && ap[1] === bp[1] && ap[2] - bp[2]) {
+			return Math.sign(ap[2] - bp[2]);
+		}
+		return 0;
+	};
+
+	const gitVerRegex = new RegExp(/v(\d{1,2}\.\d{1,2}\.\d{1,2})(-.*)?$/);
+
+	const compareGitVersions = (repoA: string, repoB: string) => {
+		const {branch: a} = parseGithubURL(repoA);
+		const {branch: b} = parseGithubURL(repoB);
+
+		if (gitVerRegex.test(a) && gitVerRegex.test(b)) {
+			return compareVersions(a.substring(1), b.substring(1));
+		}
+		else if (!gitVerRegex.test(a)) {
+			return -1;
+		}
+		else {
+			return 1;
+		}
+	};
+
+	let collectDeps = async (config: Config | VesselConfig, isRoot = false) => {
+		let allDeps = [...Object.values(config.dependencies || {})];
+		if (isRoot) {
+			allDeps = [...allDeps, ...Object.values(config['dev-dependencies'] || {})];
+		}
+		for (const pkgDetails of allDeps) {
+			const {name, repo, version} = pkgDetails;
+
+			// take root dep version or bigger one
+			if (
+				isRoot
+				|| !packages[name]
+				|| !packages[name]?.isRoot
+				&& (
+					repo && packages[name]?.repo && compareGitVersions(packages[name]?.repo || '', repo) === -1
+					|| compareVersions(packages[name]?.version, version) === -1)
+			) {
+				packages[name] = {
+					...pkgDetails,
+					isRoot,
+				};
+			}
+
+			let nestedConfig;
+
+			if (repo) {
+				const dir = formatGithubDir(name, repo);
+				nestedConfig = await readVesselConfig(dir) || {};
+			}
+			else if (!pkgDetails.path && version) {
+				const file = formatDir(name, version) + '/mops.toml';
+				nestedConfig = readConfig(file);
+			}
+
+			if (nestedConfig && !pkgDetails.path) {
+				await collectDeps(nestedConfig);
+			}
+
+			if (!versions[name]) {
+				versions[name] = [];
+			}
+
+			if (repo) {
+				const {branch} = parseGithubURL(repo);
+				versions[name]?.push(branch);
+			}
+			else if (version) {
+				versions[name]?.push(version);
+			}
+		}
+	};
+
+	let config = readConfig();
+	await collectDeps(config, true);
+
+	// show conflicts
+	if (verbose) {
+		for (let [dep, vers] of Object.entries(versions)) {
+			if (vers.length > 1) {
+				console.log(chalk.yellow('WARN:'), `Conflicting package versions "${dep}" - ${vers.join(', ')}`);
+			}
+		}
+	}
+
+	let rootDir = getRootDir();
+
+	return Object.fromEntries(
+		Object.entries(packages).map(([name, pkg]) => {
+			let version: string;
+			if (pkg.path) {
+				version = path.resolve(rootDir, pkg.path).replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
+			}
+			else if (pkg.repo) {
+				version = pkg.repo;
+			}
+			else if (pkg.version) {
+				version = pkg.version;
+			}
+			else {
+				return [name, ''];
+			}
+			return [name, version];
+		}).filter(([, version]) => version !== '')
+	);
+}