ic-mops 0.19.1 → 0.20.0

package/dist/vessel.d.ts

@@ -0,0 +1,19 @@
+export type VesselConfig = {
+    dependencies: VesselDependencies;
+    'dev-dependencies': VesselDependencies;
+};
+export type VesselDependencies = Array<{
+    name: string;
+    version?: string;
+    repo?: string;
+    path?: string;
+}>;
+export declare const readVesselConfig: (dir: string, { cache }?: {
+    cache?: 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 }?: {
+    verbose?: boolean | undefined;
+    dep?: boolean | undefined;
+    silent?: boolean | undefined;
+}) => Promise<void>;

package/dist/vessel.js

@@ -0,0 +1,154 @@
+import { existsSync, mkdirSync, createWriteStream, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { deleteSync } from 'del';
+import { execaCommand } from 'execa';
+import chalk from 'chalk';
+import logUpdate from 'log-update';
+import got from 'got';
+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) => {
+    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);
+            return null;
+        }
+        if (res.exitCode === 0) {
+            return JSON.parse(res.stdout);
+        }
+        else {
+            return res;
+        }
+    }
+    return null;
+};
+export const readVesselConfig = async (dir, { cache = true } = {}) => {
+    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')
+    ]);
+    if (!vessel || !packageSetArray) {
+        return null;
+    }
+    let repos = {};
+    for (const { name, repo, version } of packageSetArray) {
+        const { org, gitName } = parseGithubURL(repo);
+        repos[name] = `https://github.com/${org}/${gitName}#${version}`;
+    }
+    let config = {
+        dependencies: vessel.dependencies.map((name) => {
+            return { name, repo: repos[name], version: '' };
+        }),
+        'dev-dependencies': [],
+    };
+    if (cache === true) {
+        writeFileSync(cachedFile, JSON.stringify(config), 'utf-8');
+    }
+    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 readStream = got.stream(zipFile);
+    const promise = new Promise((resolve, reject) => {
+        readStream.on('error', (err) => {
+            reject(err);
+        });
+        readStream.on('downloadProgress', ({ transferred, total }) => {
+            onProgress?.(transferred, total || 2 * (1024 ** 2));
+        });
+        readStream.on('response', (response) => {
+            if (response.headers.age > 3600) {
+                console.log(chalk.red('Error: ') + 'Failure - response too old');
+                readStream.destroy(); // Destroy the stream to prevent hanging resources.
+                reject();
+                return;
+            }
+            // 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`);
+            try {
+                mkdirSync(tmpDir, { recursive: true });
+                pipeline(readStream, createWriteStream(tmpFile), (err) => {
+                    if (err) {
+                        deleteSync([tmpDir]);
+                        reject(err);
+                    }
+                    else {
+                        let options = {
+                            extract: true,
+                            strip: 1,
+                            headers: {
+                                accept: 'application/zip',
+                            },
+                        };
+                        decompress(tmpFile, dest, options).then((unzippedFiles) => {
+                            deleteSync([tmpDir]);
+                            resolve(unzippedFiles);
+                        }).catch(err => {
+                            deleteSync([tmpDir]);
+                            reject(err);
+                        });
+                    }
+                });
+            }
+            catch (err) {
+                deleteSync([tmpDir]);
+                reject(err);
+            }
+        });
+    });
+    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}`;
+    if (existsSync(dir)) {
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} (already installed) from Github`);
+    }
+    else if (isCached(cacheName)) {
+        await copyCache(cacheName, dir);
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} (cache) from Github`);
+    }
+    else {
+        mkdirSync(dir, { recursive: true });
+        let progress = (step, total) => {
+            silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} ${progressBar(step, total)}`);
+        };
+        progress(0, 2 * (1024 ** 2));
+        try {
+            await downloadFromGithub(repo, dir, progress);
+        }
+        catch (err) {
+            deleteSync([dir]);
+            throw err;
+        }
+        // add to cache
+        await addCache(cacheName, dir);
+    }
+    if (verbose) {
+        silent || logUpdate.done();
+    }
+    const config = await readVesselConfig(dir);
+    if (config) {
+        for (const { name, repo } of config.dependencies) {
+            if (repo) {
+                await installFromGithub(name, repo, { verbose, silent, dep: true });
+            }
+        }
+    }
+};

package/global.d.ts

@@ -0,0 +1,2 @@
+declare module 'pem-file';
+declare module 'get-folder-size';

package/{mops.js → mops.ts}

@@ -1,39 +1,45 @@
-import {Actor, HttpAgent} from '@dfinity/agent';
+import path from 'node:path';
+import fs from 'node:fs';
+import {Actor, HttpAgent, Identity} from '@dfinity/agent';
 import TOML from '@iarna/toml';
 import chalk from 'chalk';
-import fetch from 'node-fetch';
-import path from 'path';
-import fs from 'fs';
 import prompts from 'prompts';
 import ncp from 'ncp';
+import fetch from 'node-fetch';
 
-import {idlFactory} from './declarations/main/main.did.js';
-import {idlFactory as storageIdlFactory} from './declarations/storage/storage.did.js';
+import {idlFactory} from './declarations/main/index.js';
+import {_SERVICE} from './declarations/main/main.did.js';
+import {idlFactory as storageIdlFactory} from './declarations/storage/index.js';
+import {_SERVICE as _STORAGE_SERVICE} from './declarations/storage/storage.did.js';
 import {decodeFile} from './pem.js';
+import {Config} from './types.js';
+import {Principal} from '@dfinity/principal';
 
 
-global.fetch = fetch;
+if (!global.fetch) {
+	global.fetch = fetch as any;
+}
 
 // (!) make changes in pair with backend
 export let apiVersion = '1.2';
 
 let networkFile = new URL('./network.txt', import.meta.url);
 
-export let globalConfigDir;
-export let globalCacheDir;
+export let globalConfigDir = '';
+export let globalCacheDir = '';
 
 // OS specific dirs
 if (process.platform == 'win32') {
-	globalConfigDir = path.join(process.env.LOCALAPPDATA, 'mops/config');
-	globalCacheDir = path.join(process.env.LOCALAPPDATA, 'mops/cache');
+	globalConfigDir = path.join(process.env.LOCALAPPDATA || '', 'mops/config');
+	globalCacheDir = path.join(process.env.LOCALAPPDATA || '', 'mops/cache');
 }
 else if (process.platform == 'darwin') {
-	globalConfigDir = path.join(process.env.HOME, 'Library/Application Support/mops');
-	globalCacheDir = path.join(process.env.HOME, 'Library/Caches/mops');
+	globalConfigDir = path.join(process.env.HOME || '', 'Library/Application Support/mops');
+	globalCacheDir = path.join(process.env.HOME || '', 'Library/Caches/mops');
 }
 else {
-	globalConfigDir = path.join(process.env.HOME, '.config/mops');
-	globalCacheDir = path.join(process.env.HOME, '.cache/mops');
+	globalConfigDir = path.join(process.env.HOME || '', '.config/mops');
+	globalCacheDir = path.join(process.env.HOME || '', '.cache/mops');
 }
 // XDG overrides
 if (process.env.XDG_CONFIG_HOME) {
@@ -44,7 +50,7 @@ if (process.env.XDG_CACHE_HOME) {
 }
 
 // temp: move old config to new location
-let oldGlobalConfigDir = path.resolve(process.env.HOME || process.env.APPDATA, 'mops');
+let oldGlobalConfigDir = path.resolve(process.env.HOME || process.env.APPDATA || '/', 'mops');
 if (fs.existsSync(oldGlobalConfigDir) && !fs.existsSync(globalConfigDir)) {
 	fs.mkdirSync(globalConfigDir, {recursive: true});
 	if (fs.existsSync(path.join(oldGlobalConfigDir, 'identity.pem'))) {
@@ -71,7 +77,7 @@ if (fs.existsSync(oldGlobalConfigDir) && !fs.existsSync(globalCacheDir)) {
 	console.log('Moved cache to ' + chalk.green(globalCacheDir));
 }
 
-export function setNetwork(network) {
+export function setNetwork(network: string) {
 	fs.writeFileSync(networkFile, network);
 }
 
@@ -81,30 +87,30 @@ export function getNetwork() {
 		network = fs.readFileSync(networkFile).toString() || 'ic';
 	}
 
-	if (network === 'local') {
+	if (network === 'staging') {
 		return {
 			network,
-			host: 'http://127.0.0.1:4943',
+			host: 'https://icp-api.io',
 			canisterId: '2d2zu-vaaaa-aaaak-qb6pq-cai',
 		};
 	}
-	else if (network === 'staging') {
+	else if (network === 'ic') {
 		return {
 			network,
 			host: 'https://icp-api.io',
-			canisterId: '2d2zu-vaaaa-aaaak-qb6pq-cai',
+			canisterId: 'oknww-riaaa-aaaam-qaf6a-cai',
 		};
 	}
-	else if (network === 'ic') {
+	else {
 		return {
 			network,
-			host: 'https://icp-api.io',
-			canisterId: 'oknww-riaaa-aaaam-qaf6a-cai',
+			host: 'http://127.0.0.1:4943',
+			canisterId: '2d2zu-vaaaa-aaaak-qb6pq-cai',
 		};
 	}
 }
 
-export let getIdentity = async () => {
+export let getIdentity = async (): Promise<Identity | undefined> => {
 	let identityPem = path.resolve(globalConfigDir, 'identity.pem');
 	let identityPemEncrypted = path.resolve(globalConfigDir, 'identity.pem.encrypted');
 	if (fs.existsSync(identityPemEncrypted)) {
@@ -118,14 +124,16 @@ export let getIdentity = async () => {
 	if (fs.existsSync(identityPem)) {
 		return decodeFile(identityPem);
 	}
+	return undefined;
 };
 
-export let mainActor = async (useIdentity = false) => {
+export let mainActor = async (useIdentity = false): Promise<_SERVICE> => {
 	let network = getNetwork().network;
 	let host = getNetwork().host;
 	let canisterId = getNetwork().canisterId;
 
-	let identity = useIdentity && await getIdentity();
+	let identity = useIdentity ? await getIdentity() : undefined;
+	// @ts-ignore exactOptionalPropertyTypes
 	let agent = new HttpAgent({host, identity});
 
 	if (network === 'local') {
@@ -138,11 +146,12 @@ export let mainActor = async (useIdentity = false) => {
 	});
 };
 
-export let storageActor = async (storageId, useIdentity = false) => {
+export let storageActor = async (storageId: Principal, useIdentity = false): Promise<_STORAGE_SERVICE> => {
 	let network = getNetwork().network;
 	let host = getNetwork().host;
 
 	let identity = useIdentity && await getIdentity();
+	// @ts-ignore exactOptionalPropertyTypes
 	let agent = new HttpAgent({host, identity});
 
 	if (network === 'local') {
@@ -157,7 +166,7 @@ export let storageActor = async (storageId, useIdentity = false) => {
 
 export function getClosestConfigFile(dir = process.cwd()) {
 	if (!path.basename(dir)) {
-		return null;
+		throw '';
 	}
 	let configFile = path.join(dir, 'mops.toml');
 	if (fs.existsSync(configFile)) {
@@ -169,7 +178,7 @@ export function getClosestConfigFile(dir = process.cwd()) {
 export function getRootDir() {
 	let configFile = getClosestConfigFile();
 	if (!configFile) {
-		return null;
+		return '';
 	}
 	return path.dirname(configFile);
 }
@@ -183,34 +192,34 @@ export function checkConfigFile() {
 	return true;
 }
 
-export function progressBar(step, total) {
+export function progressBar(step: number, total: number) {
 	let done = Math.round(step / total * 10);
 	return `[${':'.repeat(done)}${' '.repeat(Math.max(0, 10 - done))}]`;
 }
 
-export async function getHighestVersion(pkgName) {
+export async function getHighestVersion(pkgName: string) {
 	let actor = await mainActor();
 	return actor.getHighestVersion(pkgName);
 }
 
-export function parseGithubURL(href) {
+export function parseGithubURL(href: string) {
 	const url = new URL(href);
 	const branch =  url.hash?.substring(1) || 'master';
 
 	let [org, gitName] = url.pathname.split('/').filter(path => !!path);
 
-	if (gitName.endsWith('.git')) {
+	if (gitName?.endsWith('.git')) {
 		gitName = gitName.substring(0, gitName.length - 4);
 	}
 
 	return {org, gitName, branch};
 }
 
-export function readConfig(configFile = getClosestConfigFile()) {
+export function readConfig(configFile = getClosestConfigFile()): Config {
 	let text = fs.readFileSync(configFile).toString();
 	let toml = TOML.parse(text);
 
-	let processDeps = (deps) => {
+	let processDeps = (deps: any) => {
 		Object.entries(deps).forEach(([name, data]) => {
 			if (!data || typeof data !== 'string') {
 				throw Error(`Invalid dependency value ${name} = "${data}"`);
@@ -233,34 +242,36 @@ export function readConfig(configFile = getClosestConfigFile()) {
 	return toml;
 }
 
-export function writeConfig(config, configFile = getClosestConfigFile()) {
-	const deps = config.dependencies || {};
-	Object.entries(deps).forEach(([name, {repo, path, version}]) => {
+export function writeConfig(config: Config, configFile = getClosestConfigFile()) {
+	let resConfig: any = {...config};
+
+	let deps = resConfig.dependencies || {};
+	Object.entries(config.dependencies || {}).forEach(([name, {repo, path, version}]) => {
 		deps[name] = repo || path || version;
 	});
 
-	const devDeps = config['dev-dependencies'] || {};
-	Object.entries(devDeps).forEach(([name, {repo, path, version}]) => {
+	let devDeps = resConfig['dev-dependencies'] || {};
+	Object.entries(config['dev-dependencies'] || {}).forEach(([name, {repo, path, version}]) => {
 		devDeps[name] = repo || path || version;
 	});
 
-	let text = TOML.stringify(config).trim();
+	let text = TOML.stringify(resConfig).trim();
 	if (fs.existsSync(configFile) && fs.readFileSync(configFile).toString().endsWith('\n')) {
 		text += '\n';
 	}
 	fs.writeFileSync(configFile, text);
 }
 
-export function formatDir(name, version) {
+export function formatDir(name: string, version: string) {
 	return path.join(getRootDir(), '.mops', `${name}@${version}`);
 }
 
-export function formatGithubDir(name, repo) {
+export function formatGithubDir(name: string, repo: string) {
 	const {branch} = parseGithubURL(repo);
 	return path.join(getRootDir(), '.mops/_github', `${name}@${branch}`);
 }
 
-export function readDfxJson() {
+export function readDfxJson(): any {
 	let dir = process.cwd();
 	let dfxJson = null;
 	for (let i = 0; i < 5; i++) {

package/package.json

@@ -1,9 +1,9 @@
 {
 	"name": "ic-mops",
-	"version": "0.19.1",
+	"version": "0.20.0",
 	"type": "module",
 	"bin": {
-		"mops": "cli.js"
+		"mops": "dist/cli.js"
 	},
 	"files": [
 		"*",
@@ -19,36 +19,61 @@
 	"author": "Zen Voich <zen.voich@gmail.com>",
 	"license": "MIT",
 	"engines": {
-		"node": ">=14.0.0"
+		"node": ">=16.0.0"
+	},
+	"scripts": {
+		"build": "tsc",
+		"bundle": "esbuild --bundle --outfile=cli.js --platform=node --packages=external --target=node16 --format=esm ./dist/cli.js",
+		"copy": "cp -r declarations templates network.txt package.json dist | true",
+		"save-network": "cp -r dist/network.txt . | true",
+		"prepare": "npm run save-network && npm run build && npm run copy",
+		"check": "tsc --project tsconfig.json --noEmit",
+		"tsc": "tsc",
+		"esbuild": "esbuild"
 	},
 	"dependencies": {
-		"@dfinity/agent": "^0.11.0",
-		"@dfinity/candid": "^0.11.0",
-		"@dfinity/identity": "^0.11.0",
-		"@dfinity/principal": "^0.11.1",
+		"@dfinity/agent": "^0.18.1",
+		"@dfinity/candid": "^0.18.1",
+		"@dfinity/identity": "^0.18.1",
+		"@dfinity/identity-secp256k1": "^0.18.1",
+		"@dfinity/principal": "^0.18.1",
 		"@iarna/toml": "^2.2.5",
 		"as-table": "^1.0.55",
-		"cacheable-request": "10.2.10",
-		"chalk": "^4.1.2",
+		"cacheable-request": "10.2.12",
+		"chalk": "^5.3.0",
 		"chokidar": "^3.5.3",
-		"commander": "^9.2.0",
+		"commander": "^11.0.0",
 		"debounce": "^1.2.1",
 		"decompress": "^4.2.1",
-		"del": "^6.0.0",
+		"del": "^7.0.0",
 		"dhall-to-json-cli": "^1.7.6",
-		"eslint": "^8.15.0",
-		"execa": "6.1.0",
+		"eslint": "^8.45.0",
+		"execa": "7.1.1",
 		"get-folder-size": "^4.0.0",
-		"glob": "^8.1.0",
-		"globby": "^13.1.1",
-		"got": "12.5.3",
+		"glob": "^10.3.3",
+		"globby": "^13.2.2",
+		"got": "13.0.0",
 		"log-update": "^5.0.1",
-		"minimatch": "^5.0.1",
+		"minimatch": "^9.0.3",
 		"ncp": "^2.0.0",
-		"node-fetch": "^3.3.0",
+		"node-fetch": "^3.3.2",
 		"pem-file": "^1.0.1",
 		"prompts": "^2.4.2",
 		"stream-to-promise": "^3.0.0",
-		"tar": "^6.1.13"
+		"tar": "^6.1.15"
+	},
+	"devDependencies": {
+		"@tsconfig/strictest": "^2.0.1",
+		"@types/debounce": "^1.2.1",
+		"@types/decompress": "^4.2.4",
+		"@types/glob": "^8.1.0",
+		"@types/ncp": "^2.0.5",
+		"@types/node": "^20.4.4",
+		"@types/prompts": "^2.4.4",
+		"@types/stream-to-promise": "^2.2.1",
+		"@types/tar": "^6.1.5",
+		"esbuild": "^0.18.16",
+		"tsx": "^3.12.7",
+		"typescript": "^5.1.6"
 	}
 }

package/{parallel.js → parallel.ts}

@@ -1,5 +1,5 @@
-export async function parallel(threads, items, fn) {
-	return new Promise((resolve) => {
+export async function parallel(threads: number, items: any[], fn: CallableFunction) {
+	return new Promise<void>((resolve) => {
 		let busyThreads = 0;
 		items = items.slice();
 

package/{pem.js → pem.ts}

@@ -1,9 +1,10 @@
-import fs from 'fs';
-import {Ed25519KeyIdentity, Secp256k1KeyIdentity} from '@dfinity/identity';
+import fs from 'node:fs';
+import {Ed25519KeyIdentity} from '@dfinity/identity';
+import {Secp256k1KeyIdentity} from '@dfinity/identity-secp256k1';
 import pemfile from 'pem-file';
 import crypto from 'crypto';
 
-export function decodeFile(file, password) {
+export function decodeFile(file: string, password?: string) {
 	let rawKey = fs.readFileSync(file);
 	if (password) {
 		return decode(decrypt(rawKey, password));
@@ -11,24 +12,24 @@ export function decodeFile(file, password) {
 	return decode(rawKey);
 }
 
-function decode(rawKey) {
-	var buf = pemfile.decode(rawKey);
+function decode(rawKey: Buffer) {
+	let buf: Buffer = pemfile.decode(rawKey);
 	if (rawKey.includes('EC PRIVATE KEY')) {
 		if (buf.length != 118) {
 			throw 'expecting byte length 118 but got ' + buf.length;
 		}
-		return Secp256k1KeyIdentity.fromSecretKey(buf.slice(7, 39));
+		return Secp256k1KeyIdentity.fromSecretKey(buf.subarray(7, 39));
 	}
 	if (buf.length != 85) {
 		throw 'expecting byte length 85 but got ' + buf.length;
 	}
-	let secretKey = Buffer.concat([buf.slice(16, 48), buf.slice(53, 85)]);
+	let secretKey = Buffer.concat([buf.subarray(16, 48), buf.subarray(53, 85)]);
 	return Ed25519KeyIdentity.fromSecretKey(secretKey);
 }
 
 let algorithm = 'aes-256-ctr';
 
-export function encrypt(buffer, password) {
+export function encrypt(buffer: Buffer, password: string) {
 	let key = crypto.createHash('sha256').update(password).digest('base64').slice(0, 32);
 	// Create an initialization vector
 	let iv = crypto.randomBytes(16);
@@ -39,12 +40,12 @@ export function encrypt(buffer, password) {
 	return result;
 }
 
-function decrypt(encrypted, password) {
+function decrypt(encrypted: Buffer, password: string) {
 	let key = crypto.createHash('sha256').update(password).digest('base64').slice(0, 32);
 	// Get the iv: the first 16 bytes
-	let iv = encrypted.slice(0, 16);
+	let iv = encrypted.subarray(0, 16);
 	// Get the rest
-	encrypted = encrypted.slice(16);
+	encrypted = encrypted.subarray(16);
 	// Create a decipher
 	let decipher = crypto.createDecipheriv(algorithm, key, iv);
 	// Actually decrypt it

package/templates/mops-test.yml

@@ -18,7 +18,7 @@ jobs:
           node-version: 18
 
       - name: install moc
-        run: npx mocv use 0.9.3
+        run: npx mocv use latest
 
       - name: install mops
         run: npm i ic-mops -g

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+	"extends": ["@tsconfig/strictest/tsconfig.json"],
+	"include": ["**/*.ts", "**/*.js"],
+	"exclude": ["node_modules", "dist", "dist.js", "declarations/**/*.js"],
+	"compilerOptions": {
+		"types": ["node"],
+		"target": "ES2021",
+		"outDir": "./dist",
+		"allowJs": true,
+		"module": "nodenext",
+		"moduleResolution": "nodenext",
+		"noEmitOnError": false,
+		"noPropertyAccessFromIndexSignature": false,
+		"declaration": true
+	}
+}

package/types.ts

@@ -0,0 +1,29 @@
+export type Config = {
+	package?: {
+		name: string;
+		version: string;
+		description?: string;
+		license?: string;
+		repository?: string;
+		keywords?: string[];
+		baseDir?: string;
+		readme?: string;
+		files?: string[];
+		homepage?: string;
+		documentation?: string;
+		dfx?: string;
+		moc?: string;
+		donation?: string;
+	};
+	dependencies?: Dependencies;
+	'dev-dependencies'?: Dependencies;
+};
+
+export type Dependencies = Record<string, Dependency>;
+
+export type Dependency = {
+	name: string;
+	version?: string; // mops package
+	repo?: string; // github package
+	path?: string; // local package
+}