ic-mops 0.19.0 → 0.20.0

package/dist/declarations/storage/index.js

@@ -0,0 +1,30 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from './storage.did.js';
+export { idlFactory } from './storage.did.js';
+
+/**
+ *
+ * @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("./storage.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,
+  });
+};

package/dist/declarations/storage/storage.did

@@ -0,0 +1,46 @@
+type StorageStats =
+ record {
+   cyclesBalance: nat;
+   fileCount: nat;
+   memorySize: nat;
+ };
+type Storage =
+ service {
+   acceptCycles: () -> ();
+   deleteFile: (FileId) -> ();
+   downloadChunk: (FileId, nat) -> (Result_2) query;
+   finishUpload: (FileId) -> ();
+   getFileIdsRange: (nat, nat) -> (vec FileId) query;
+   getFileMeta: (FileId) -> (Result_1) query;
+   getStats: () -> (StorageStats) query;
+   startUpload: (FileMeta) -> (Result);
+   updateFileOwners: (FileId, vec principal) -> ();
+   uploadChunk: (FileId, nat, Chunk) -> ();
+ };
+type Result_2 =
+ variant {
+   err: Err;
+   ok: Chunk;
+ };
+type Result_1 =
+ variant {
+   err: Err;
+   ok: FileMeta;
+ };
+type Result =
+ variant {
+   err: Err;
+   ok;
+ };
+type FileMeta =
+ record {
+   chunkCount: nat;
+   id: FileId__1;
+   owners: vec principal;
+   path: text;
+ };
+type FileId__1 = text;
+type FileId = text;
+type Err = text;
+type Chunk = blob;
+service : () -> Storage

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

@@ -0,0 +1,37 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+
+export type Chunk = Array<number>;
+export type Err = string;
+export type FileId = string;
+export type FileId__1 = string;
+export interface FileMeta {
+  'id' : FileId__1,
+  'owners' : Array<Principal>,
+  'path' : string,
+  'chunkCount' : bigint,
+}
+export type Result = { 'ok' : null } |
+  { 'err' : Err };
+export type Result_1 = { 'ok' : FileMeta } |
+  { 'err' : Err };
+export type Result_2 = { 'ok' : Chunk } |
+  { 'err' : Err };
+export interface Storage {
+  'acceptCycles' : ActorMethod<[], undefined>,
+  'deleteFile' : ActorMethod<[FileId], undefined>,
+  'downloadChunk' : ActorMethod<[FileId, bigint], Result_2>,
+  'finishUpload' : ActorMethod<[FileId], undefined>,
+  'getFileIdsRange' : ActorMethod<[bigint, bigint], Array<FileId>>,
+  'getFileMeta' : ActorMethod<[FileId], Result_1>,
+  'getStats' : ActorMethod<[], StorageStats>,
+  'startUpload' : ActorMethod<[FileMeta], Result>,
+  'updateFileOwners' : ActorMethod<[FileId, Array<Principal>], undefined>,
+  'uploadChunk' : ActorMethod<[FileId, bigint, Chunk], undefined>,
+}
+export interface StorageStats {
+  'fileCount' : bigint,
+  'cyclesBalance' : bigint,
+  'memorySize' : bigint,
+}
+export interface _SERVICE extends Storage {}

package/dist/declarations/storage/storage.did.js

@@ -0,0 +1,38 @@
+export const idlFactory = ({ IDL }) => {
+  const FileId = IDL.Text;
+  const Chunk = IDL.Vec(IDL.Nat8);
+  const Err = IDL.Text;
+  const Result_2 = IDL.Variant({ 'ok' : Chunk, 'err' : Err });
+  const FileId__1 = IDL.Text;
+  const FileMeta = IDL.Record({
+    'id' : FileId__1,
+    'owners' : IDL.Vec(IDL.Principal),
+    'path' : IDL.Text,
+    'chunkCount' : IDL.Nat,
+  });
+  const Result_1 = IDL.Variant({ 'ok' : FileMeta, 'err' : Err });
+  const StorageStats = IDL.Record({
+    'fileCount' : IDL.Nat,
+    'cyclesBalance' : IDL.Nat,
+    'memorySize' : IDL.Nat,
+  });
+  const Result = IDL.Variant({ 'ok' : IDL.Null, 'err' : Err });
+  const Storage = IDL.Service({
+    'acceptCycles' : IDL.Func([], [], []),
+    'deleteFile' : IDL.Func([FileId], [], []),
+    'downloadChunk' : IDL.Func([FileId, IDL.Nat], [Result_2], ['query']),
+    'finishUpload' : IDL.Func([FileId], [], []),
+    'getFileIdsRange' : IDL.Func(
+        [IDL.Nat, IDL.Nat],
+        [IDL.Vec(FileId)],
+        ['query'],
+      ),
+    'getFileMeta' : IDL.Func([FileId], [Result_1], ['query']),
+    'getStats' : IDL.Func([], [StorageStats], ['query']),
+    'startUpload' : IDL.Func([FileMeta], [Result], []),
+    'updateFileOwners' : IDL.Func([FileId, IDL.Vec(IDL.Principal)], [], []),
+    'uploadChunk' : IDL.Func([FileId, IDL.Nat, Chunk], [], []),
+  });
+  return Storage;
+};
+export const init = ({ IDL }) => { return []; };

package/dist/mops.d.ts

@@ -0,0 +1,33 @@
+import { Identity } from '@dfinity/agent';
+import { _SERVICE } from './declarations/main/main.did.js';
+import { _SERVICE as _STORAGE_SERVICE } from './declarations/storage/storage.did.js';
+import { Config } from './types.js';
+import { Principal } from '@dfinity/principal';
+export declare let apiVersion: string;
+export declare let globalConfigDir: string;
+export declare let globalCacheDir: string;
+export declare function setNetwork(network: string): void;
+export declare function getNetwork(): {
+    network: string;
+    host: string;
+    canisterId: string;
+};
+export declare let getIdentity: () => Promise<Identity | undefined>;
+export declare let mainActor: (useIdentity?: boolean) => Promise<_SERVICE>;
+export declare let storageActor: (storageId: Principal, useIdentity?: boolean) => Promise<_STORAGE_SERVICE>;
+export declare function getClosestConfigFile(dir?: string): string;
+export declare function getRootDir(): string;
+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;
+    branch: string;
+};
+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;
+export declare function formatGithubDir(name: string, repo: string): string;
+export declare function readDfxJson(): any;
+export declare function checkApiCompatibility(): Promise<boolean>;

package/dist/mops.js

@@ -0,0 +1,259 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { Actor, HttpAgent } from '@dfinity/agent';
+import TOML from '@iarna/toml';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import ncp from 'ncp';
+import fetch from 'node-fetch';
+import { idlFactory } from './declarations/main/index.js';
+import { idlFactory as storageIdlFactory } from './declarations/storage/index.js';
+import { decodeFile } from './pem.js';
+if (!global.fetch) {
+    global.fetch = fetch;
+}
+// (!) 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 = '';
+// OS specific dirs
+if (process.platform == 'win32') {
+    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');
+}
+else {
+    globalConfigDir = path.join(process.env.HOME || '', '.config/mops');
+    globalCacheDir = path.join(process.env.HOME || '', '.cache/mops');
+}
+// XDG overrides
+if (process.env.XDG_CONFIG_HOME) {
+    globalConfigDir = path.join(process.env.XDG_CONFIG_HOME, 'mops');
+}
+if (process.env.XDG_CACHE_HOME) {
+    globalCacheDir = path.join(process.env.XDG_CACHE_HOME, 'mops');
+}
+// temp: move old config to new location
+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'))) {
+        fs.copyFileSync(path.join(oldGlobalConfigDir, 'identity.pem'), path.join(globalConfigDir, 'identity.pem'));
+    }
+    if (fs.existsSync(path.join(oldGlobalConfigDir, 'identity.pem.encrypted'))) {
+        fs.copyFileSync(path.join(oldGlobalConfigDir, 'identity.pem.encrypted'), path.join(globalConfigDir, 'identity.pem.encrypted'));
+    }
+    console.log('Moved config to ' + chalk.green(globalConfigDir));
+}
+// temp: move old cache to new location
+if (fs.existsSync(oldGlobalConfigDir) && !fs.existsSync(globalCacheDir)) {
+    fs.mkdirSync(globalCacheDir, { recursive: true });
+    ncp.ncp(path.join(oldGlobalConfigDir, 'packages'), path.join(globalCacheDir, 'packages'), {
+        stopOnErr: true,
+        clobber: false,
+    }, (err) => {
+        if (err) {
+            console.log('Error moving config: ', err);
+            fs.rmSync(globalCacheDir, { recursive: true, force: true });
+        }
+    });
+    console.log('Moved cache to ' + chalk.green(globalCacheDir));
+}
+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 === 'staging') {
+        return {
+            network,
+            host: 'https://icp-api.io',
+            canisterId: '2d2zu-vaaaa-aaaak-qb6pq-cai',
+        };
+    }
+    else if (network === 'ic') {
+        return {
+            network,
+            host: 'https://icp-api.io',
+            canisterId: 'oknww-riaaa-aaaam-qaf6a-cai',
+        };
+    }
+    else {
+        return {
+            network,
+            host: 'http://127.0.0.1:4943',
+            canisterId: '2d2zu-vaaaa-aaaak-qb6pq-cai',
+        };
+    }
+}
+export let getIdentity = async () => {
+    let identityPem = path.resolve(globalConfigDir, 'identity.pem');
+    let identityPemEncrypted = path.resolve(globalConfigDir, 'identity.pem.encrypted');
+    if (fs.existsSync(identityPemEncrypted)) {
+        let res = await prompts({
+            type: 'password',
+            name: 'value',
+            message: 'Enter password:'
+        });
+        return await decodeFile(identityPemEncrypted, res.value);
+    }
+    if (fs.existsSync(identityPem)) {
+        return decodeFile(identityPem);
+    }
+    return undefined;
+};
+export let mainActor = async (useIdentity = false) => {
+    let network = getNetwork().network;
+    let host = getNetwork().host;
+    let canisterId = getNetwork().canisterId;
+    let identity = useIdentity ? await getIdentity() : undefined;
+    // @ts-ignore exactOptionalPropertyTypes
+    let agent = new HttpAgent({ host, identity });
+    if (network === 'local') {
+        await agent.fetchRootKey();
+    }
+    return Actor.createActor(idlFactory, {
+        agent,
+        canisterId,
+    });
+};
+export let storageActor = async (storageId, useIdentity = false) => {
+    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') {
+        await agent.fetchRootKey();
+    }
+    return Actor.createActor(storageIdlFactory, {
+        agent,
+        canisterId: storageId,
+    });
+};
+export function getClosestConfigFile(dir = process.cwd()) {
+    if (!path.basename(dir)) {
+        throw '';
+    }
+    let configFile = path.join(dir, 'mops.toml');
+    if (fs.existsSync(configFile)) {
+        return configFile;
+    }
+    return getClosestConfigFile(path.resolve(dir, '..'));
+}
+export function getRootDir() {
+    let configFile = getClosestConfigFile();
+    if (!configFile) {
+        return '';
+    }
+    return path.dirname(configFile);
+}
+export function checkConfigFile() {
+    let configFile = getClosestConfigFile();
+    if (!configFile) {
+        console.log(chalk.red('Error: ') + `Config file 'mops.toml' not found. Please run ${chalk.green('mops init')} first`);
+        return false;
+    }
+    return true;
+}
+export function progressBar(step, total) {
+    let done = Math.round(step / total * 10);
+    return `[${':'.repeat(done)}${' '.repeat(Math.max(0, 10 - done))}]`;
+}
+export async function getHighestVersion(pkgName) {
+    let actor = await mainActor();
+    return actor.getHighestVersion(pkgName);
+}
+export function parseGithubURL(href) {
+    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')) {
+        gitName = gitName.substring(0, gitName.length - 4);
+    }
+    return { org, gitName, branch };
+}
+export function readConfig(configFile = getClosestConfigFile()) {
+    let text = fs.readFileSync(configFile).toString();
+    let toml = TOML.parse(text);
+    let processDeps = (deps) => {
+        Object.entries(deps).forEach(([name, data]) => {
+            if (!data || typeof data !== 'string') {
+                throw Error(`Invalid dependency value ${name} = "${data}"`);
+            }
+            if (data.startsWith('https://github.com/')) {
+                deps[name] = { name, repo: data, version: '' };
+            }
+            else if (data.match(/^(\.?\.)?\//)) {
+                deps[name] = { name, repo: '', path: data, version: '' };
+            }
+            else {
+                deps[name] = { name, repo: '', version: data };
+            }
+        });
+    };
+    processDeps(toml.dependencies || {});
+    processDeps(toml['dev-dependencies'] || {});
+    return toml;
+}
+export function writeConfig(config, configFile = getClosestConfigFile()) {
+    let resConfig = { ...config };
+    let deps = resConfig.dependencies || {};
+    Object.entries(config.dependencies || {}).forEach(([name, { repo, path, version }]) => {
+        deps[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(resConfig).trim();
+    if (fs.existsSync(configFile) && fs.readFileSync(configFile).toString().endsWith('\n')) {
+        text += '\n';
+    }
+    fs.writeFileSync(configFile, text);
+}
+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}`);
+}
+export function readDfxJson() {
+    let dir = process.cwd();
+    let dfxJson = null;
+    for (let i = 0; i < 5; i++) {
+        let file = path.resolve(dir, 'dfx.json');
+        if (fs.existsSync(file)) {
+            dfxJson = JSON.parse(fs.readFileSync(file).toString());
+            break;
+        }
+        dir = path.resolve(dir, '..');
+    }
+    return dfxJson;
+}
+// warn on minor mismatch
+// err on major mismatch
+export async function checkApiCompatibility() {
+    let actor = await mainActor();
+    let backendApiVer = await actor.getApiVersion();
+    if (backendApiVer.split('.')[0] !== apiVersion.split('.')[0]) {
+        console.log(chalk.red('ERR: ') + `CLI incompatible with backend. CLI v${apiVersion}, Backend v${backendApiVer}`);
+        console.log('Run ' + chalk.greenBright('npm i -g ic-mops') + ' to upgrade cli.');
+        return false;
+    }
+    else if (backendApiVer.split('.')[1] !== apiVersion.split('.')[1]) {
+        console.log('-'.repeat(50));
+        console.log(chalk.yellow('WARN: ') + `CLI probably incompatible with backend. CLI v${apiVersion}, Backend v${backendApiVer}`);
+        console.log('Recommended to run ' + chalk.greenBright('npm i -g ic-mops') + ' to upgrade cli.');
+        console.log('-'.repeat(50));
+    }
+    return true;
+}

package/dist/package.json

@@ -0,0 +1,79 @@
+{
+	"name": "ic-mops",
+	"version": "0.20.0",
+	"type": "module",
+	"bin": {
+		"mops": "dist/cli.js"
+	},
+	"files": [
+		"*",
+		"!network.txt",
+		"!.mops",
+		"/templates"
+	],
+	"homepage": "https://mops.one",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/ZenVoich/mops.git"
+	},
+	"author": "Zen Voich <zen.voich@gmail.com>",
+	"license": "MIT",
+	"engines": {
+		"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.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.12",
+		"chalk": "^5.3.0",
+		"chokidar": "^3.5.3",
+		"commander": "^11.0.0",
+		"debounce": "^1.2.1",
+		"decompress": "^4.2.1",
+		"del": "^7.0.0",
+		"dhall-to-json-cli": "^1.7.6",
+		"eslint": "^8.45.0",
+		"execa": "7.1.1",
+		"get-folder-size": "^4.0.0",
+		"glob": "^10.3.3",
+		"globby": "^13.2.2",
+		"got": "13.0.0",
+		"log-update": "^5.0.1",
+		"minimatch": "^9.0.3",
+		"ncp": "^2.0.0",
+		"node-fetch": "^3.3.2",
+		"pem-file": "^1.0.1",
+		"prompts": "^2.4.2",
+		"stream-to-promise": "^3.0.0",
+		"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/dist/parallel.d.ts

@@ -0,0 +1 @@
+export declare function parallel(threads: number, items: any[], fn: CallableFunction): Promise<void>;

package/dist/parallel.js

@@ -0,0 +1,24 @@
+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/dist/pem.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Ed25519KeyIdentity } from '@dfinity/identity';
+import { Secp256k1KeyIdentity } from '@dfinity/identity-secp256k1';
+export declare function decodeFile(file: string, password?: string): Secp256k1KeyIdentity | Ed25519KeyIdentity;
+export declare function encrypt(buffer: Buffer, password: string): Buffer;

package/dist/pem.js

@@ -0,0 +1,49 @@
+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) {
+    let rawKey = fs.readFileSync(file);
+    if (password) {
+        return decode(decrypt(rawKey, password));
+    }
+    return decode(rawKey);
+}
+function decode(rawKey) {
+    let buf = 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.subarray(7, 39));
+    }
+    if (buf.length != 85) {
+        throw 'expecting byte length 85 but got ' + buf.length;
+    }
+    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) {
+    let key = crypto.createHash('sha256').update(password).digest('base64').slice(0, 32);
+    // Create an initialization vector
+    let iv = crypto.randomBytes(16);
+    // Create a new cipher using the algorithm, key, and iv
+    let cipher = crypto.createCipheriv(algorithm, key, iv);
+    // Create the new (encrypted) buffer
+    let result = Buffer.concat([iv, cipher.update(buffer), cipher.final()]);
+    return result;
+}
+function decrypt(encrypted, password) {
+    let key = crypto.createHash('sha256').update(password).digest('base64').slice(0, 32);
+    // Get the iv: the first 16 bytes
+    let iv = encrypted.subarray(0, 16);
+    // Get the rest
+    encrypted = encrypted.subarray(16);
+    // Create a decipher
+    let decipher = crypto.createDecipheriv(algorithm, key, iv);
+    // Actually decrypt it
+    let result = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+    return result;
+}

package/dist/templates/mops-test.yml

@@ -0,0 +1,30 @@
+name: mops test
+
+on:
+  push:
+    branches:
+      - main
+      - master
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+
+      - name: install moc
+        run: npx mocv use latest
+
+      - name: install mops
+        run: npm i ic-mops -g
+
+      - name: install mops packages
+        run: mops install
+
+      - name: run tests
+        run: mops test

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+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;
+    repo?: string;
+    path?: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};