ic-mops 0.0.1

package/.eslintrc.json

@@ -0,0 +1,28 @@
+{
+    "env": {
+        "node": true,
+        "es2021": true
+    },
+    "extends": "eslint:recommended",
+    "parserOptions": {
+        "sourceType": "module"
+    },
+    "rules": {
+        "indent": [
+            "error",
+            "tab"
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "single"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ]
+    }
+}

package/README.md

@@ -0,0 +1,16 @@
+# MOPS
+CLI tool for [MOPS](http://mops.one)
+
+## Usage
+
+**Install cli**
+```
+npm i -g ic-mops
+```
+
+**Install specific Motoko package**
+```
+mops i <package_name>
+```
+
+For more docs visit http://mops.one

package/cli.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import {program} from 'commander';
+import chalk from 'chalk';
+import TOML from '@iarna/toml';
+
+import {init} from './commands/init.js';
+import {install} from './commands/install.js';
+import {publish} from './commands/publish.js';
+import {importPem} from './commands/import-identity.js';
+import {sources} from './commands/sources.js';
+import {getLastVersion, getNetwork, setNetwork} from './mops.js';
+import {whoami} from './commands/whoami.js';
+import {installAll} from './commands/install-all.js';
+import logUpdate from 'log-update';
+
+let cwd = process.cwd();
+let configFile = path.join(cwd, 'mops.toml');
+
+function wirteConfig(config) {
+	fs.writeFileSync(configFile, TOML.stringify(config).trim());
+}
+
+program.name('mops');
+
+// init
+program
+	.command('init [name]')
+	.description('Create mops.toml')
+	.action(async (name) => {
+		await init(name);
+	});
+
+// install
+program
+	.command('install [pkg]')
+	.alias('i')
+	.alias('add')
+	.description('Install package and save it as a dependency in the mops.toml file')
+	.option('--verbose', '')
+	.action(async (pkg, options) => {
+		let config = {};
+		let exists = fs.existsSync(configFile);
+		if (exists) {
+			let text = fs.readFileSync(configFile).toString();
+			config = TOML.parse(text);
+		}
+		else {
+			console.log(chalk.red('Error: ') + `mops.toml not found. Please run ${chalk.green('mops init')} first`);
+			return;
+		}
+		if (!config.dependencies) {
+			config.dependencies = {};
+		}
+
+		if (!pkg) {
+			installAll(options);
+		}
+		else {
+			let version = await getLastVersion(pkg);
+			await install(pkg, version, options.verbose);
+
+			config.dependencies[pkg] = version;
+			wirteConfig(config);
+			logUpdate.clear();
+			console.log(chalk.green('Package installed ') + `${pkg} = '${version}'`);
+		}
+	});
+
+// publish
+program
+	.command('publish')
+	.description('Publish package to the mops registry')
+	.action(async () => {
+		await publish();
+	});
+
+// set-network
+program
+	.command('set-network <network>')
+	.description('Set network local|dev|ic')
+	.action(async (network) => {
+		await setNetwork(network);
+		console.log(`Selected '${network}' network`);
+	});
+
+// get-network
+program
+	.command('get-network')
+	.description('Get network')
+	.action(async () => {
+		console.log(getNetwork().network);
+	});
+
+// import-identity
+program
+	.command('import-identity <data>')
+	.description('Import .pem file data to use as identity')
+	.action(async (data) => {
+		await importPem(data);
+		whoami();
+	});
+
+// sources
+program
+	.command('sources')
+	.description('for dfx packtool')
+	.option('--verbose', '')
+	.action(async (options) => {
+		await sources(options);
+	});
+
+// whoami
+program
+	.command('whoami')
+	.description('prints your principal')
+	.action(async () => {
+		whoami();
+	});
+
+program.parse();

package/commands/import-identity.js

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import chalk from 'chalk';
+
+export async function importPem(data) {
+	try {
+		let url = new URL('../identity.pem', import.meta.url);
+		fs.writeFileSync(url, data);
+		console.log(chalk.green('Success'));
+	}
+	catch (err) {
+		console.log(chalk.red('Error: ') + err);
+	}
+}
+
+// export async function pemFile(file) {
+// 	try {
+// 		if (!file.endsWith('.pem')) {
+// 			throw 'Please specify .pem file';
+// 		}
+// 		if (!fs.existsSync(file)) {
+// 			throw 'File not found ' + file;
+// 		}
+// 		let url = new URL('./pem-file', import.meta.url);
+// 		fs.writeFileSync(url, file);
+// 		console.log(chalk.green('Success'));
+// 	}
+// 	catch (e) {
+// 		console.log(chalk.red('Error: ') + e);
+// 	}
+// }

package/commands/init.js

@@ -0,0 +1,32 @@
+import TOML from '@iarna/toml';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+
+export async function init(name = {}) {
+	let configFile = path.join(process.cwd(), 'mops.toml');
+	let exists = fs.existsSync(configFile);
+	if (exists) {
+		console.log(chalk.yellow('mops.toml already exists'));
+		return;
+	}
+	let config = {};
+	if (name) {
+		config = {
+			package: {
+				name: name,
+				version: '0.1.0',
+				description: '',
+				repository: '',
+			}
+		};
+	}
+	// TODO: add last version of 'base' package?
+	// else {
+	// 	config.dependencies = {};
+	// }
+
+	fs.writeFileSync(configFile, TOML.stringify(config).trim());
+
+	console.log(chalk.green('mops.toml has been created'));
+}

package/commands/install-all.js

@@ -0,0 +1,20 @@
+import chalk from 'chalk';
+import logUpdate from 'log-update';
+import {checkConfigFile, readConfig} from '../mops.js';
+import {install} from './install.js';
+
+export async function installAll({verbose} = {}) {
+	if (!checkConfigFile()) {
+		return;
+	}
+
+	let config = readConfig();
+	let deps = Object.entries(config.dependencies || {});
+
+	for (let [pkg, ver] of deps) {
+		await install(pkg, ver, verbose);
+	}
+
+	logUpdate.clear();
+	console.log(chalk.green('All packages installed'));
+}

package/commands/install.js

@@ -0,0 +1,61 @@
+import path from 'path';
+import fs from 'fs';
+import logUpdate from 'log-update';
+import {checkConfigFile, getLastVersion, mainActor, progressBar, readConfig} from '../mops.js';
+import {parallel} from '../parallel.js';
+
+export async function install(pkg, version = '', verbose = false, dep = false) {
+	if (!checkConfigFile()) {
+		return;
+	}
+
+	if (!version) {
+		version = await getLastVersion(pkg);
+	}
+
+	let dir = path.join(process.cwd(), '.mops', `${pkg}@${version}`);
+	let actor = await mainActor();
+
+	// cache
+	if (fs.existsSync(dir)) {
+		logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (cache)`);
+	}
+	// no cache
+	else {
+		fs.mkdirSync(dir, {recursive: true});
+
+		let filesIds = await actor.getFileIds(pkg, version);
+
+		// progress
+		let total = filesIds.length + 1;
+		let step = 0;
+		let progress = () => {
+			step++;
+			logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} ${progressBar(step, total)}`);
+		};
+
+		// download files
+		progress();
+		await parallel(8, filesIds, async (fileId) => {
+			let file = await actor.getFile(fileId);
+			fs.mkdirSync(path.join(dir, path.dirname(file.path)), {recursive: true});
+			fs.writeFileSync(path.join(dir, file.path), Buffer.from(file.content));
+			progress();
+		});
+
+		// TODO: slow (update call)
+		// if (!dep) {
+		// 	await actor.notifyInstall(pkg, version);
+		// }
+	}
+
+	if (verbose) {
+		logUpdate.done();
+	}
+
+	// install dependencies
+	let config = readConfig(path.join(dir, 'mops.toml'));
+	for (let [name, version] of Object.entries(config.dependencies || {})) {
+		await install(name, version, verbose, true);
+	}
+}

package/commands/publish.js

@@ -0,0 +1,212 @@
+import fs from 'fs';
+import chalk from 'chalk';
+import logUpdate from 'log-update';
+import {Principal} from '@dfinity/principal';
+import {globbySync} from 'globby';
+import minimatch from 'minimatch';
+import prompts from 'prompts';
+import {checkConfigFile, getIdentity, mainActor, progressBar, readConfig} from '../mops.js';
+import {parallel} from '../parallel.js';
+
+export async function publish() {
+	if (!checkConfigFile()) {
+		return;
+	}
+
+	let config = readConfig();
+
+	// validate
+	for (let key of Object.keys(config)) {
+		if (!['package', 'dependencies', 'permissions', 'scripts'].includes(key)) {
+			console.log(chalk.red('Error: ') + `Unknown config section [${key}]`);
+			return;
+		}
+	}
+
+	// required fields
+	if (!config.package) {
+		console.log(chalk.red('Error: ') + 'Please specify [package] section in your mops.toml');
+		return;
+	}
+	for (let key of ['name', 'version']) {
+		if (!config.package[key]) {
+			console.log(chalk.red('Error: ') + `Please specify "${key}" in [config] section in your mops.toml`);
+			return;
+		}
+	}
+
+	// desired fields
+	for (let key of ['description', 'repository']) {
+		if (!config.package[key]) {
+			let res = await prompts({
+				type: 'confirm',
+				name: 'ok',
+				message: `Missing recommended config key "${key}", publish anyway?`,
+			});
+			if (!res.ok) {
+				return;
+			}
+		}
+	}
+
+	let packageKeys = [
+		'name',
+		'version',
+		'keywords',
+		'description',
+		'repository',
+		'documentation',
+		'homepage',
+		'readme',
+		'license',
+		'isPrivate',
+		'files',
+		'dfx',
+		'moc',
+		'donation',
+	];
+	for (let key of Object.keys(config.package)) {
+		if (!packageKeys.includes(key)) {
+			console.log(chalk.red('Error: ') + `Unknown config key 'package.${key}'`);
+			return;
+		}
+	}
+
+	// check lengths
+	let keysMax = {
+		name: 50,
+		version: 20,
+		keywords: 5,
+		description: 200,
+		repository: 300,
+		documentation: 300,
+		homepage: 300,
+		readme: 100,
+		license: 30,
+		files: 20,
+		dfx: 10,
+		moc: 10,
+		donation: 64,
+	};
+
+	for (let [key, max] of Object.entries(keysMax)) {
+		if (config.package[key] && config.package[key].length > max) {
+			console.log(chalk.red('Error: ') + `package.${key} value max length is ${max}`);
+			return;
+		}
+	}
+
+	if (config.package.dependencies && Object.keys(config.package.dependencies).length > 100) {
+		console.log(chalk.red('Error: ') + 'max dependencies is 100');
+		return;
+	}
+
+	if (config.package.permissions && Object.keys(config.package.permissions).length > 50) {
+		console.log(chalk.red('Error: ') + 'max permissions is 50');
+		return;
+	}
+
+	if (config.package.keywords) {
+		for (let keyword of config.package.keywords) {
+			if (keyword.length > 20) {
+				console.log(chalk.red('Error: ') + 'max keyword length is 20');
+				return;
+			}
+		}
+	}
+
+	if (config.package.files) {
+		for (let file of config.package.files) {
+			if (file.startsWith('/') || file.startsWith('../')) {
+				console.log(chalk.red('Error: ') + 'file path cannot start with \'/\' or \'../\'');
+				return;
+			}
+		}
+	}
+
+	// map fields
+	let backendPkgConfig = {
+		name: config.package.name,
+		version: config.package.version,
+		keywords: config.package.keywords || [],
+		description: config.package.description || '',
+		repository: config.package.repository || '',
+		homepage: config.package.homepage || '',
+		documentation: config.package.documentation || '',
+		readme: 'README.md',
+		license: config.package.license || '',
+		isPrivate: false,
+		owner: getIdentity()?.getPrincipal() || Principal.anonymous(),
+		dfx: config.package.dfx || '',
+		moc: config.package.moc || '',
+		donation: config.package.donation || '',
+		dependencies: (Object.entries(config.dependencies || {})).map(([name, version]) => {
+			return {name, version};
+		}),
+		permissions: [],
+		scripts: [],
+	};
+
+	let defaultFiles = [
+		'mops.toml',
+		'README.md',
+		'LICENSE',
+		'!.mops/**',
+	];
+	let files = config.package.files || ['**/*.mo'];
+	files = [...files, ...defaultFiles];
+	files = globbySync([...files, ...defaultFiles]);
+
+	// check required files
+	if (!files.includes('mops.toml')) {
+		console.log(chalk.red('Error: ') + ' please add mops.toml file');
+		return;
+	}
+	if (!files.includes('README.md')) {
+		console.log(chalk.red('Error: ') + ' please add README.md file');
+		return;
+	}
+
+	// check allowed exts
+	for (let file of files) {
+		if (!minimatch(file, '**/*.{mo,did,md,toml}')) {
+			console.log(chalk.red('Error: ') + `file ${file} has unsupported extension. Allowed: .mo, .did, .md, .toml`);
+			return;
+		}
+	}
+
+	// progress
+	let total = files.length + 2;
+	let step = 0;
+	function progress() {
+		step++;
+		logUpdate(`Publishing ${config.package.name}@${config.package.version} ${progressBar(step, total)}`);
+	}
+
+	// upload config
+	progress();
+	let actor = await mainActor();
+	let publishing = await actor.startPublish(backendPkgConfig);
+	if (publishing.err) {
+		console.log(chalk.red('Error: ') + publishing.err);
+		return;
+	}
+	let puiblishingId = publishing.ok;
+
+	// upload files
+	await parallel(8, files, async (file) => {
+		progress();
+		let content = fs.readFileSync(file);
+		await actor.uploadFile(puiblishingId, file, Array.from(content));
+	});
+
+	// finish
+	progress();
+	let res = await actor.finishPublish(puiblishingId);
+	if (res.err) {
+		console.log(chalk.red('Error: ') + res.err);
+		return;
+	}
+
+	console.log(chalk.green('Published ') + `${config.package.name}@${config.package.version}`);
+}

package/commands/sources.js

@@ -0,0 +1,101 @@
+import path from 'path';
+import fs from 'fs';
+import chalk from 'chalk';
+import {install} from './install.js';
+import {getLastVersion, readConfig} from '../mops.js';
+
+function rootDir(cwd = process.cwd()) {
+	let configFile = path.join(cwd, 'mops.toml');
+	if (fs.existsSync(configFile)) {
+		return cwd;
+	}
+	if (!path.basename(cwd)) {
+		console.log(chalk.red('Error: ') + 'Cannot find mops.toml');
+		return;
+	}
+	return rootDir(path.join(cwd, '..'));
+}
+
+// TODO: resolve deps for a specific file to avoid conflicts
+// TODO: remove base-unofficial
+export async function sources({verbose} = {}) {
+	let root = rootDir();
+	if (!root) {
+		return;
+	}
+
+	let packages = {};
+	let versions = {};
+
+	let compareVersions = (a, b) => {
+		let ap = a.split('.').map(x => x |0);
+		let bp = b.split('.').map(x => x |0);
+		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;
+	};
+
+	let collectDeps = (config, isRoot = false) => {
+		for (let [dep, ver] of Object.entries(config.dependencies || {})) {
+			// take root dep ver or bigger one
+			if (isRoot || !packages[dep] || compareVersions(packages[dep], ver) === -1) {
+				packages[dep] = ver;
+			}
+
+			let config = readConfig(path.join(root, `.mops/${dep}@${ver}/mops.toml`));
+			collectDeps(config);
+
+			if (!versions[dep]) {
+				versions[dep] = [];
+			}
+			versions[dep].push(ver);
+		}
+	};
+
+	let config = readConfig(path.join(root, 'mops.toml'));
+	collectDeps(config, true);
+
+	// install base-unofficial
+	if (!packages['base-unofficial']) {
+		let dirs = fs.readdirSync(path.join(root, '.mops'));
+		let downloadedPackages = Object.fromEntries(dirs.map((dir) => {
+			return dir.split('@');
+		}));
+
+		if (downloadedPackages['base-unofficial']) {
+			packages['base-unofficial'] = downloadedPackages['base-unofficial'];
+		}
+		else {
+			let version = await getLastVersion('base-unofficial');
+			await install('base-unofficial', version, false, true);
+			packages['base-unofficial'] = version;
+		}
+	}
+
+	// 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(', ')}`);
+			}
+		}
+	}
+
+	// sources
+	for (let [name, ver] of Object.entries(packages)) {
+		let pkgDir = path.relative(process.cwd(), path.join(root, `.mops/${name}@${ver}`));
+		console.log(`--package ${name} ${pkgDir}`);
+
+		// fallback base to base-unofficial
+		if (name == 'base-unofficial' && !packages.base) {
+			console.log(`--package base ${pkgDir}`);
+		}
+	}
+}

package/commands/uninstall.js

@@ -0,0 +1,38 @@
+import {checkConfigFile} from '../mops.js';
+import path from 'path';
+import fs from 'fs';
+import del from 'del';
+import chalk from 'chalk';
+
+export async function uninstall(pkg, version) {
+	if (!checkConfigFile()) {
+		return;
+	}
+
+	// TODO: check if deps relate on this package
+	let pkgDir = path.join(process.cwd(), '.mops', `${pkg}@${version}`);
+
+	if (!fs.existsSync(pkgDir)) {
+		console.log(`No cache to remove ${pkg} = '${version}'`);
+		return;
+	}
+
+	// don't remove if there are dependents
+	// let dependents = getDependents(pkg, version);
+	// if (dependents.length) {
+	// 	console.log(`Cache left ${pkg} = '${version}' (dependents: ${dependents})`)
+	// 	return;
+	// }
+
+	del.sync([`${pkgDir}/**`]);
+
+	console.log(chalk.green('Package removed ') + `${pkg} = '${version}'`);
+
+	// remove dependencies
+	// let text = fs.readFileSync(path.join(pkgDir, 'mops.toml')).toString();
+	// let config = TOML.parse(text);
+
+	// for (let [name, version] of Object.entries(config.dependencies)) {
+	// 	remove(name, version);
+	// }
+}

package/commands/whoami.js

@@ -0,0 +1,14 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import {getIdentity} from '../mops.js';
+
+export function whoami() {
+	let identityPem = new URL('../identity.pem', import.meta.url);
+	if (fs.existsSync(identityPem)) {
+		let identity = getIdentity();
+		console.log(identity.getPrincipal().toText());
+	}
+	else {
+		console.log(chalk.red('Error: ') + 'identity not found. Run ' + chalk.greenBright('mops import-identity') + ' command.');
+	}
+}

package/declarations/main/index.js

@@ -0,0 +1,38 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from './main.did.js';
+export { idlFactory } from './main.did.js';
+// CANISTER_ID is replaced by webpack based on node environment
+export const canisterId = process.env.MAIN_CANISTER_ID;
+
+/**
+ * 
+ * @param {string | import("@dfinity/principal").Principal} canisterId Canister ID of Agent
+ * @param {{agentOptions?: import("@dfinity/agent").HttpAgentOptions; actorOptions?: import("@dfinity/agent").ActorConfig}} [options]
+ * @return {import("@dfinity/agent").ActorSubclass<import("./main.did.js")._SERVICE>}
+ */
+ export const createActor = (canisterId, options) => {
+  const agent = new HttpAgent({ ...options?.agentOptions });
+  
+  // Fetch root key for certificate validation during development
+  if(process.env.NODE_ENV !== "production") {
+    agent.fetchRootKey().catch(err=>{
+      console.warn("Unable to fetch root key. Check to ensure that your local replica is running");
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options?.actorOptions,
+  });
+};
+  
+/**
+ * A ready-to-use agent for the main canister
+ * @type {import("@dfinity/agent").ActorSubclass<import("./main.did.js")._SERVICE>}
+ */
+ export const main = createActor(canisterId);

package/declarations/main/main.did

@@ -0,0 +1,89 @@
+type Version = text;
+type Time = int;
+type Text = text;
+type Script = 
+ record {
+   name: text;
+   value: text;
+ };
+type Result_1 = 
+ variant {
+   err: PublishingErr;
+   ok: PublishingId;
+ };
+type Result = 
+ variant {
+   err: Err;
+   ok;
+ };
+type PublishingId = text;
+type PublishingErr = text;
+type Permission = 
+ record {
+   access: Access;
+   user: principal;
+ };
+type PackageSummary = 
+ record {
+   description: text;
+   downloadsInLast30Days: nat;
+   downloadsTotal: nat;
+   keywords: vec text;
+   name: PackageName;
+   updatedAt: Time;
+   version: text;
+ };
+type PackageName__1 = text;
+type PackageName = text;
+type PackageConfig = 
+ record {
+   dependencies: vec Dependency;
+   description: text;
+   dfx: text;
+   documentation: text;
+   donation: text;
+   homepage: text;
+   isPrivate: bool;
+   keywords: vec text;
+   license: text;
+   moc: text;
+   name: PackageName;
+   owner: principal;
+   permissions: vec Permission;
+   readme: text;
+   repository: text;
+   scripts: vec Script;
+   version: text;
+ };
+type FileId = text;
+type File = 
+ record {
+   content: blob;
+   id: FileId;
+   path: Text;
+ };
+type Err = text;
+type Dependency = 
+ record {
+   name: PackageName;
+   version: text;
+ };
+type Access = 
+ variant {
+   readOnly;
+   readWrite;
+ };
+service : {
+  finishPublish: (PublishingId) -> (Result);
+  getConfig: (PackageName__1, Version) -> (PackageConfig) query;
+  getFile: (FileId) -> (File) query;
+  getFileIds: (PackageName__1, Version) -> (vec FileId) query;
+  getLastConfig: (PackageName__1) -> (PackageConfig) query;
+  getLastVersion: (PackageName__1) -> (Version) query;
+  getReadmeFile: (PackageName__1, Version) -> (File) query;
+  notifyInstall: (PackageName__1, Version) -> () oneway;
+  search: (Text) -> (vec PackageSummary) query;
+  startPublish: (PackageConfig) -> (Result_1);
+  uploadFile: (PublishingId, Text, blob) -> (Result);
+  whoami: () -> (Text) query;
+}

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

@@ -0,0 +1,68 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+
+export type Access = { 'readOnly' : null } |
+  { 'readWrite' : null };
+export interface Dependency { 'name' : PackageName, 'version' : string }
+export type Err = string;
+export interface File {
+  'id' : FileId,
+  'content' : Array<number>,
+  'path' : Text,
+}
+export type FileId = string;
+export interface PackageConfig {
+  'dfx' : string,
+  'moc' : string,
+  'permissions' : Array<Permission>,
+  'scripts' : Array<Script>,
+  'owner' : Principal,
+  'documentation' : string,
+  'name' : PackageName,
+  'homepage' : string,
+  'description' : string,
+  'version' : string,
+  'keywords' : Array<string>,
+  'donation' : string,
+  'isPrivate' : boolean,
+  'repository' : string,
+  'dependencies' : Array<Dependency>,
+  'license' : string,
+  'readme' : string,
+}
+export type PackageName = string;
+export type PackageName__1 = string;
+export interface PackageSummary {
+  'name' : PackageName,
+  'downloadsTotal' : bigint,
+  'downloadsInLast30Days' : bigint,
+  'description' : string,
+  'version' : string,
+  'keywords' : Array<string>,
+  'updatedAt' : Time,
+}
+export interface Permission { 'access' : Access, 'user' : Principal }
+export type PublishingErr = string;
+export type PublishingId = string;
+export type Result = { 'ok' : null } |
+  { 'err' : Err };
+export type Result_1 = { 'ok' : PublishingId } |
+  { 'err' : PublishingErr };
+export interface Script { 'value' : string, 'name' : string }
+export type Text = string;
+export type Time = bigint;
+export type Version = string;
+export interface _SERVICE {
+  'finishPublish' : ActorMethod<[PublishingId], Result>,
+  'getConfig' : ActorMethod<[PackageName__1, Version], PackageConfig>,
+  'getFile' : ActorMethod<[FileId], File>,
+  'getFileIds' : ActorMethod<[PackageName__1, Version], Array<FileId>>,
+  'getLastConfig' : ActorMethod<[PackageName__1], PackageConfig>,
+  'getLastVersion' : ActorMethod<[PackageName__1], Version>,
+  'getReadmeFile' : ActorMethod<[PackageName__1, Version], File>,
+  'notifyInstall' : ActorMethod<[PackageName__1, Version], undefined>,
+  'search' : ActorMethod<[Text], Array<PackageSummary>>,
+  'startPublish' : ActorMethod<[PackageConfig], Result_1>,
+  'uploadFile' : ActorMethod<[PublishingId, Text, Array<number>], Result>,
+  'whoami' : ActorMethod<[], Text>,
+}

package/declarations/main/main.did.js

@@ -0,0 +1,77 @@
+export const idlFactory = ({ IDL }) => {
+  const PublishingId = IDL.Text;
+  const Err = IDL.Text;
+  const Result = IDL.Variant({ 'ok' : IDL.Null, 'err' : Err });
+  const PackageName__1 = IDL.Text;
+  const Version = IDL.Text;
+  const Access = IDL.Variant({ 'readOnly' : IDL.Null, 'readWrite' : IDL.Null });
+  const Permission = IDL.Record({ 'access' : Access, 'user' : IDL.Principal });
+  const Script = IDL.Record({ 'value' : IDL.Text, 'name' : IDL.Text });
+  const PackageName = IDL.Text;
+  const Dependency = IDL.Record({ 'name' : PackageName, 'version' : IDL.Text });
+  const PackageConfig = IDL.Record({
+    'dfx' : IDL.Text,
+    'moc' : IDL.Text,
+    'permissions' : IDL.Vec(Permission),
+    'scripts' : IDL.Vec(Script),
+    'owner' : IDL.Principal,
+    'documentation' : IDL.Text,
+    'name' : PackageName,
+    'homepage' : IDL.Text,
+    'description' : IDL.Text,
+    'version' : IDL.Text,
+    'keywords' : IDL.Vec(IDL.Text),
+    'donation' : IDL.Text,
+    'isPrivate' : IDL.Bool,
+    'repository' : IDL.Text,
+    'dependencies' : IDL.Vec(Dependency),
+    'license' : IDL.Text,
+    'readme' : IDL.Text,
+  });
+  const FileId = IDL.Text;
+  const Text = IDL.Text;
+  const File = IDL.Record({
+    'id' : FileId,
+    'content' : IDL.Vec(IDL.Nat8),
+    'path' : Text,
+  });
+  const Time = IDL.Int;
+  const PackageSummary = IDL.Record({
+    'name' : PackageName,
+    'downloadsTotal' : IDL.Nat,
+    'downloadsInLast30Days' : IDL.Nat,
+    'description' : IDL.Text,
+    'version' : IDL.Text,
+    'keywords' : IDL.Vec(IDL.Text),
+    'updatedAt' : Time,
+  });
+  const PublishingErr = IDL.Text;
+  const Result_1 = IDL.Variant({ 'ok' : PublishingId, 'err' : PublishingErr });
+  return IDL.Service({
+    'finishPublish' : IDL.Func([PublishingId], [Result], []),
+    'getConfig' : IDL.Func(
+        [PackageName__1, Version],
+        [PackageConfig],
+        ['query'],
+      ),
+    'getFile' : IDL.Func([FileId], [File], ['query']),
+    'getFileIds' : IDL.Func(
+        [PackageName__1, Version],
+        [IDL.Vec(FileId)],
+        ['query'],
+      ),
+    'getLastConfig' : IDL.Func([PackageName__1], [PackageConfig], ['query']),
+    'getLastVersion' : IDL.Func([PackageName__1], [Version], ['query']),
+    'getReadmeFile' : IDL.Func([PackageName__1, Version], [File], ['query']),
+    'notifyInstall' : IDL.Func([PackageName__1, Version], [], ['oneway']),
+    'search' : IDL.Func([Text], [IDL.Vec(PackageSummary)], ['query']),
+    'startPublish' : IDL.Func([PackageConfig], [Result_1], []),
+    'uploadFile' : IDL.Func(
+        [PublishingId, Text, IDL.Vec(IDL.Nat8)],
+        [Result],
+        [],
+      ),
+    'whoami' : IDL.Func([], [Text], ['query']),
+  });
+};
+export const init = ({ IDL }) => { return []; };

package/mops.js

@@ -0,0 +1,90 @@
+import {Actor, HttpAgent} 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 {idlFactory} from './declarations/main/main.did.js';
+import {decodeFile} from './pem.js';
+
+
+global.fetch = fetch;
+
+let networkFile = new URL('./network.txt', import.meta.url);
+
+export function setNetwork(network) {
+	fs.writeFileSync(networkFile, network);
+}
+
+export function getNetwork() {
+	let network = 'ic';
+	if (fs.existsSync(networkFile)) {
+		network = fs.readFileSync(networkFile).toString() || 'ic';
+	}
+
+	if (network === 'local') {
+		let ids = JSON.parse(fs.readFileSync(new URL('../.dfx/local/canister_ids.json', import.meta.url)).toString());
+		return {
+			network,
+			host: 'http://127.0.0.1:8000',
+			canisterId: ids.main.local,
+		};
+	}
+	else if (network === 'ic') {
+		return {
+			network,
+			host: 'https://mainnet.dfinity.network',
+			canisterId: 'oknww-riaaa-aaaam-qaf6a-cai',
+		};
+	}
+}
+
+export let getIdentity = () => {
+	let identityPem = new URL('./identity.pem', import.meta.url);
+	if (fs.existsSync(identityPem)) {
+		return decodeFile(identityPem);
+	}
+};
+
+export let mainActor = async () => {
+	let network = getNetwork().network;
+	let host = getNetwork().host;
+	let canisterId = getNetwork().canisterId;
+
+	let identity = getIdentity();
+	let agent = new HttpAgent({host, identity});
+
+	if (network === 'local') {
+		await agent.fetchRootKey();
+	}
+
+	return Actor.createActor(idlFactory, {
+		agent,
+		canisterId,
+	});
+};
+
+export function checkConfigFile() {
+	let configFile = path.join(process.cwd(), 'mops.toml');
+	if (!fs.existsSync(configFile)) {
+		console.log(chalk.red('Error: ') + `Config file not found ${configFile}`);
+		return false;
+	}
+	return true;
+}
+
+export function progressBar(step, total) {
+	let done = Math.round(step / total * 10);
+	return `[${':'.repeat(done)}${' '.repeat(10 - done)}]`;
+}
+
+export async function getLastVersion(pkgName) {
+	let actor = await mainActor();
+	return actor.getLastVersion(pkgName);
+}
+
+export function readConfig(configFile = path.join(process.cwd(), 'mops.toml')) {
+	let text = fs.readFileSync(configFile).toString();
+	return TOML.parse(text);
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+	"name": "ic-mops",
+	"version": "0.0.1",
+	"type": "module",
+	"bin": {
+		"mops": "cli.js"
+	},
+	"dependencies": {
+		"@dfinity/agent": "^0.11.0",
+		"@dfinity/candid": "^0.11.0",
+		"@dfinity/identity": "^0.11.0",
+		"@dfinity/principal": "^0.11.1",
+		"@iarna/toml": "^2.2.5",
+		"chalk": "^4.1.2",
+		"commander": "^9.2.0",
+		"del": "^6.0.0",
+		"eslint": "^8.15.0",
+		"globby": "^13.1.1",
+		"log-update": "^5.0.1",
+		"minimatch": "^5.0.1",
+		"node-fetch": "^2.6.7",
+		"pem-file": "^1.0.1",
+		"prompts": "^2.4.2"
+	}
+}

package/parallel.js

@@ -0,0 +1,25 @@
+export async function parallel(threads, items, fn) {
+	return new Promise((resolve) => {
+		let busyThreads = 0;
+		items = items.slice();
+
+		let loop = () => {
+			if (!items.length) {
+				if (busyThreads === 0) {
+					resolve();
+				}
+				return;
+			}
+			if (busyThreads >= threads) {
+				return;
+			}
+			busyThreads++;
+			fn(items.shift()).then(() => {
+				busyThreads--;
+				loop();
+			});
+			loop();
+		};
+		loop();
+	});
+}

package/pem.js

@@ -0,0 +1,17 @@
+import fs from 'fs';
+import {Ed25519KeyIdentity} from '@dfinity/identity';
+import pemfile from 'pem-file';
+
+export function decodeFile(file) {
+	const rawKey = fs.readFileSync(file).toString();
+	return decode(rawKey);
+}
+
+export function decode(rawKey) {
+	var buf = pemfile.decode(rawKey);
+	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)]);
+	return Ed25519KeyIdentity.fromSecretKey(secretKey);
+}