ic-mops 0.19.0 → 0.20.0

package/dist/cli.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { program } from 'commander';
+import chalk from 'chalk';
+import { Principal } from '@dfinity/principal';
+import { init } from './commands/init.js';
+import { publish } from './commands/publish.js';
+import { importPem } from './commands/import-identity.js';
+import { sources } from './commands/sources.js';
+import { checkApiCompatibility, getNetwork, setNetwork, apiVersion, checkConfigFile, mainActor } from './mops.js';
+import { whoami } from './commands/whoami.js';
+import { installAll } from './commands/install-all.js';
+import { search } from './commands/search.js';
+import { add } from './commands/add.js';
+import { cacheSize, cleanCache } from './cache.js';
+import { test } from './commands/test.js';
+import { template } from './commands/template.js';
+import { selfUpdate } from './commands/self-update.js';
+import { remove } from './commands/remove.js';
+import { getUserProp, setUserProp } from './commands/user.js';
+import { bump } from './commands/bump.js';
+// import {docs} from './commands/docs.js';
+program.name('mops');
+// --version
+let packageJson = JSON.parse(fs.readFileSync(new URL('package.json', import.meta.url)).toString());
+program.version(`CLI ${packageJson.version}\nAPI ${apiVersion}`, '-v --version');
+// init
+program
+    .command('init [name]')
+    .description('Create mops.toml')
+    .action(async (name) => {
+    await init(name);
+});
+// add
+program
+    .command('add <pkg>')
+    .description('Install the package and save it to mops.toml')
+    .option('--dev')
+    .option('--verbose')
+    .action(async (pkg, options) => {
+    if (!checkConfigFile()) {
+        process.exit(1);
+    }
+    await add(pkg, options);
+});
+// remove
+program
+    .command('remove <pkg>')
+    .alias('rm')
+    .description('Remove package and update mops.toml')
+    .option('--dev', 'Remove from dev-dependencies instead of dependencies')
+    .option('--verbose', 'Show more information')
+    .option('--dry-run', 'Do not actually remove anything')
+    .action(async (pkg, options) => {
+    if (!checkConfigFile()) {
+        process.exit(1);
+    }
+    await remove(pkg, options);
+});
+// install
+program
+    .command('install [pkg]')
+    .alias('i')
+    .description('Install all dependencies specified in mops.toml')
+    .option('--verbose')
+    .action(async (pkg, options) => {
+    if (!checkConfigFile()) {
+        process.exit(1);
+    }
+    let compatible = await checkApiCompatibility();
+    if (!compatible) {
+        return;
+    }
+    if (pkg) {
+        // @deprecated
+        console.log(chalk.yellow('Consider using the \'mops add\' command to install a specific package.'));
+        await add(pkg, options);
+    }
+    else {
+        await installAll(options);
+    }
+});
+// publish
+program
+    .command('publish')
+    .description('Publish package to the mops registry')
+    .option('--no-docs', 'Do not generate docs')
+    .action(async (options) => {
+    if (!checkConfigFile()) {
+        process.exit(1);
+    }
+    let compatible = await checkApiCompatibility();
+    if (compatible) {
+        await publish(options);
+    }
+});
+// set-network
+program
+    .command('set-network <network>')
+    .alias('sn')
+    .description('Set network local|dev|ic')
+    .action(async (network) => {
+    await setNetwork(network);
+    console.log(`Selected '${network}' network`);
+});
+// get-network
+program
+    .command('get-network')
+    .alias('gn')
+    .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);
+    await whoami();
+});
+// sources
+program
+    .command('sources')
+    .description('for dfx packtool')
+    .option('--verbose')
+    .action(async (options) => {
+    if (!checkConfigFile()) {
+        process.exit(1);
+    }
+    await installAll({ silent: true });
+    let sourcesArr = await sources(options);
+    console.log(sourcesArr.join('\n'));
+});
+// whoami
+program
+    .command('whoami')
+    .description('Print your principal')
+    .action(async () => {
+    await whoami();
+});
+// search
+program
+    .command('search <text>')
+    .description('Search for packages')
+    .action(async (text) => {
+    await search(text);
+});
+// cache
+program
+    .command('cache [sub-command]')
+    .description('Manage cache')
+    .action(async (sub) => {
+    if (sub == 'clean') {
+        await cleanCache();
+        console.log('Cache cleaned');
+    }
+    else if (sub == 'size') {
+        let size = await cacheSize();
+        console.log('Cache size is ' + size);
+    }
+    else {
+        console.log('Unknown sub command. Available sub commands: clean, size');
+    }
+});
+// test
+program
+    .command('test [filter]')
+    .description('Run tests')
+    .option('-w, --watch', 'Enable watch mode')
+    .action(async (filter, options) => {
+    await test(filter, options);
+});
+// template
+program
+    .command('template')
+    .description('Apply template')
+    .action(async () => {
+    if (!checkConfigFile()) {
+        process.exit(1);
+    }
+    await template();
+});
+// docs
+// program
+// 	.command('docs')
+// 	.description('Generate documentation (experimental)')
+// 	.action(async () => {
+// 		if (!checkConfigFile()) {
+// 			process.exit(1);
+// 		}
+// 		await docs();
+// 	});
+// self update
+program
+    .command('self-update')
+    .description('Update mops CLI to the latest version')
+    .option('--detached')
+    .option('--force')
+    .action(async (options) => {
+    if (options.force) {
+        selfUpdate(options);
+    }
+    else {
+        console.log('Please run \'npm i -g ic-mops\'');
+    }
+});
+// user
+program
+    .command('user set|get <prop> [value]')
+    .description('User settings')
+    .action(async (sub, prop, value) => {
+    if (sub == 'get') {
+        await getUserProp(prop);
+    }
+    else if (sub == 'set') {
+        if (!value) {
+            console.log('error: missing required argument "value"');
+            return;
+        }
+        await setUserProp(prop, value);
+    }
+    else {
+        console.log('Unknown sub command. Available sub commands: set, get');
+    }
+});
+// airdrop
+program
+    .command('airdrop <check|claim> [canister]')
+    .action(async (sub, canister) => {
+    let main = await mainActor(true);
+    if (sub === 'check') {
+        let amount = await main.getAirdropAmount();
+        if (amount === 0n) {
+            console.log('No airdrop available');
+            return;
+        }
+        console.log(`You can claim ${Number(amount) / 1000000000000} TCycles`);
+    }
+    else if (sub === 'claim') {
+        let principal;
+        try {
+            principal = Principal.fromText(canister);
+        }
+        catch (err) {
+            console.log('Invalid canister id');
+            console.log(err);
+            return;
+        }
+        console.log('Sending cycles to the canister ' + canister);
+        let res = await main.claimAirdrop(principal);
+        console.log(res);
+    }
+    else {
+        console.log('Unknown sub command. Available sub commands: check, claim');
+    }
+});
+// bump
+program
+    .command('bump [major|minor|patch]')
+    .description('Bump current package version')
+    .action(async (part) => {
+    bump(part);
+});
+program.parse();

package/dist/commands/add.d.ts

@@ -0,0 +1,4 @@
+export declare function add(name: string, { verbose, dev }?: {
+    verbose?: boolean | undefined;
+    dev?: boolean | undefined;
+}): Promise<void>;

package/dist/commands/add.js

@@ -0,0 +1,82 @@
+import path from 'node:path';
+import chalk from 'chalk';
+import logUpdate from 'log-update';
+import { checkConfigFile, getHighestVersion, parseGithubURL, readConfig, writeConfig } from '../mops.js';
+import { installFromGithub } from '../vessel.js';
+import { install } from './install.js';
+export async function add(name, { verbose = false, dev = false } = {}) {
+    if (!checkConfigFile()) {
+        return;
+    }
+    let config = readConfig();
+    if (dev) {
+        if (!config['dev-dependencies']) {
+            config['dev-dependencies'] = {};
+        }
+    }
+    else {
+        if (!config.dependencies) {
+            config.dependencies = {};
+        }
+    }
+    let pkgDetails;
+    // local package
+    if (name.startsWith('./') || name.startsWith('../') || name.startsWith('/')) {
+        pkgDetails = {
+            name: path.parse(name).name === '.' ? '_' : path.parse(name).name,
+            path: name,
+            repo: '',
+            version: '',
+        };
+    }
+    // github package
+    else if (name.startsWith('https://github.com') || name.split('/').length > 1) {
+        const { org, gitName, branch } = parseGithubURL(name);
+        pkgDetails = {
+            name: parseGithubURL(name).gitName,
+            repo: `https://github.com/${org}/${gitName}#${branch}`,
+            version: '',
+        };
+    }
+    // mops package
+    else {
+        let ver;
+        if (name.includes('@')) {
+            // @ts-ignore
+            [name, ver] = name.split('@');
+        }
+        else {
+            let versionRes = await getHighestVersion(name);
+            if ('err' in versionRes) {
+                console.log(chalk.red('Error: ') + versionRes.err);
+                return;
+            }
+            ver = versionRes.ok;
+        }
+        pkgDetails = {
+            name: name,
+            repo: '',
+            version: ver,
+        };
+    }
+    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) {
+            return;
+        }
+    }
+    const depsProp = dev ? 'dev-dependencies' : 'dependencies';
+    let deps = config[depsProp];
+    if (deps) {
+        deps[pkgDetails.name] = pkgDetails;
+    }
+    else {
+        throw Error(`Invalid config file: [${depsProp}] not found`);
+    }
+    writeConfig(config);
+    logUpdate.clear();
+    console.log(chalk.green('Package installed ') + `${pkgDetails.name} = "${pkgDetails.repo || pkgDetails.path || pkgDetails.version}"`);
+}

package/dist/commands/bump.d.ts

@@ -0,0 +1 @@
+export declare function bump(part: string): Promise<void>;

package/dist/commands/bump.js

@@ -0,0 +1,50 @@
+import prompts from 'prompts';
+import chalk from 'chalk';
+import { checkConfigFile, readConfig, writeConfig } from '../mops.js';
+export async function bump(part) {
+    if (!checkConfigFile()) {
+        return;
+    }
+    if (part && !['major', 'minor', 'patch'].includes(part)) {
+        console.log(chalk.red('Unknown version part. Available parts: major, minor, patch'));
+        process.exit(1);
+    }
+    let config = readConfig();
+    if (!config.package) {
+        console.log(chalk.red('No [package] section found in mops.toml.'));
+        process.exit(1);
+    }
+    console.log(`Current version: ${chalk.yellow.bold(config.package.version)}`);
+    if (!part) {
+        let res = await prompts({
+            type: 'select',
+            name: 'part',
+            message: 'Select new version:',
+            choices: [
+                { title: `${updateVersion(config.package.version, 'major')} ${chalk.dim('(major, breaking changes)')}`, value: 'major' },
+                { title: `${updateVersion(config.package.version, 'minor')} ${chalk.dim('(minor, new features)')}`, value: 'minor' },
+                { title: `${updateVersion(config.package.version, 'patch')} ${chalk.dim('(patch, bug fixes)')}`, value: 'patch' },
+            ],
+            initial: 2,
+        });
+        if (!res.part) {
+            return;
+        }
+        part = res.part;
+    }
+    config.package.version = updateVersion(config.package.version, part);
+    writeConfig(config);
+    console.log(`Updated version: ${chalk.green.bold(config.package.version)}`);
+}
+function updateVersion(version, part) {
+    let parts = version.split('.');
+    let idx = ['major', 'minor', 'patch'].indexOf(part);
+    if (!parts[idx]) {
+        throw new Error(`Invalid version part: ${part}`);
+    }
+    parts[idx] = String(parseInt(parts[idx] || '0') + 1);
+    for (let i = idx + 1; i < parts.length; i++) {
+        parts[i] = '0';
+    }
+    return parts.join('.');
+}

package/dist/commands/docs.d.ts

@@ -0,0 +1,3 @@
+export declare function docs({ silent }?: {
+    silent?: boolean | undefined;
+}): Promise<void>;

package/dist/commands/docs.js

@@ -0,0 +1,78 @@
+import { spawn, execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { globSync } from 'glob';
+import { deleteSync } from 'del';
+import tar from 'tar';
+import streamToPromise from 'stream-to-promise';
+import { getRootDir } from '../mops.js';
+let moDoc;
+export async function docs({ silent = false } = {}) {
+    let rootDir = getRootDir();
+    let docsDir = path.join(rootDir, '.mops/.docs');
+    let docsDirRelative = path.relative(process.cwd(), docsDir);
+    deleteSync([docsDir], { force: true });
+    // detect mocv
+    if (process.env.DFX_MOC_PATH && process.env.DFX_MOC_PATH.includes('mocv/versions')) {
+        moDoc = process.env.DFX_MOC_PATH.replace(/\/moc$/, '/mo-doc');
+    }
+    else {
+        moDoc = execSync('dfx cache show').toString().trim() + '/mo-doc';
+    }
+    // generate docs
+    await new Promise((resolve) => {
+        let proc = spawn(moDoc, [`--source=${path.join(rootDir, 'src')}`, `--output=${docsDirRelative}`, '--format=adoc']);
+        // stdout
+        proc.stdout.on('data', (data) => {
+            let text = data.toString().trim();
+            let failedText = 'Failed to extract documentation';
+            if (text.includes(failedText)) {
+                console.log(text.replaceAll(failedText, chalk.yellow('Warning: ') + failedText));
+            }
+            silent || console.log('stdout', text);
+        });
+        // stderr
+        let stderr = '';
+        proc.stderr.on('data', (data) => {
+            let text = data.toString().trim();
+            if (text.includes('syntax error')) {
+                console.log(chalk.red('Error:'), text);
+                process.exit(1);
+            }
+            if (text.includes('No such file or directory') || text.includes('Couldn\'t find a module expression')) {
+                silent || console.log(text);
+                return;
+            }
+            stderr += text;
+        });
+        // exit
+        proc.on('exit', (code) => {
+            // if no source files found
+            if (code === 2 && !stderr) {
+                resolve();
+                return;
+            }
+            if (code !== 0) {
+                console.log(chalk.red('Error:'), code, stderr);
+                process.exit(1);
+            }
+            resolve();
+        });
+    });
+    // create archive
+    let ignore = [
+        `${docsDir}/**/*.test.adoc`,
+        `${docsDir}/test/**/*`,
+    ];
+    let files = globSync(`${docsDir}/**/*.adoc`, { ignore }).map(f => path.relative(docsDir, f));
+    if (files.length) {
+        let stream = tar.create({
+            cwd: docsDir,
+            gzip: true,
+            portable: true,
+        }, files).pipe(fs.createWriteStream(path.join(docsDir, 'docs.tgz')));
+        await streamToPromise(stream);
+    }
+    silent || console.log(`${chalk.green('Documentation generated')} at ${docsDirRelative}`);
+}

package/dist/commands/import-identity.d.ts

@@ -0,0 +1 @@
+export declare function importPem(data: string): Promise<void>;

package/dist/commands/import-identity.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { deleteSync } from 'del';
+import { globalConfigDir } from '../mops.js';
+import { encrypt } from '../pem.js';
+export async function importPem(data) {
+    try {
+        if (!fs.existsSync(globalConfigDir)) {
+            fs.mkdirSync(globalConfigDir);
+        }
+        let res = await prompts({
+            type: 'password',
+            name: 'password',
+            message: 'Enter password to encrypt identity.pem',
+        });
+        let password = res.password;
+        if (!password) {
+            let res = await prompts({
+                type: 'confirm',
+                name: 'ok',
+                message: 'Are you sure you don\'t want to protect your identity.pem with a password?',
+            });
+            if (!res.ok) {
+                console.log('aborted');
+                return;
+            }
+        }
+        let identityPem = path.resolve(globalConfigDir, 'identity.pem');
+        let identityPemEncrypted = path.resolve(globalConfigDir, 'identity.pem.encrypted');
+        deleteSync([identityPem, identityPemEncrypted], { force: true });
+        // encrypted
+        if (password) {
+            let encrypted = await encrypt(Buffer.from(data), password);
+            fs.writeFileSync(identityPemEncrypted, encrypted);
+        }
+        // unencrypted
+        else {
+            fs.writeFileSync(identityPem, data);
+        }
+        console.log(chalk.green('Success'));
+    }
+    catch (err) {
+        console.log(chalk.red('Error: ') + err);
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function init(name?: string): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,82 @@
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import chalk from 'chalk';
+import { checkApiCompatibility, mainActor, readDfxJson, writeConfig } from '../mops.js';
+import { installAll } from './install-all.js';
+import { readVesselConfig } from '../vessel.js';
+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;
+    }
+    console.log('Initializing...');
+    let config = {};
+    let vesselConfig = { dependencies: [], 'dev-dependencies': [] };
+    let deps = {};
+    const vesselFile = path.join(process.cwd(), 'vessel.dhall');
+    if (fs.existsSync(vesselFile)) {
+        console.log('Reading vessel.dhall file');
+        const res = await readVesselConfig(process.cwd(), { cache: false });
+        if (res) {
+            vesselConfig = { ...res };
+        }
+    }
+    if (vesselConfig.dependencies) {
+        deps = {};
+        for (const dep of (vesselConfig.dependencies || [])) {
+            deps[dep.name] = dep;
+        }
+    }
+    // lib mode
+    if (name) {
+        config.package = {
+            name,
+            version: '0.1.0',
+            description: '',
+            repository: '',
+        };
+        if (deps) {
+            config.dependencies = deps;
+        }
+        writeConfig(config, configFile);
+        if (Object.keys(config.dependencies || {}).length) {
+            await installAll({ verbose: true });
+        }
+    }
+    // project mode
+    if (!name) {
+        let compatible = await checkApiCompatibility();
+        if (!compatible) {
+            return;
+        }
+        let dfxJson = readDfxJson();
+        let dfxVersion = dfxJson?.dfx || '';
+        if (!dfxVersion) {
+            try {
+                let res = execSync('dfx --version').toString();
+                let match = res.match(/\d+\.\d+\.\d+/);
+                if (match) {
+                    dfxVersion = match[0];
+                }
+            }
+            catch { }
+        }
+        let actor = await mainActor();
+        let defaultPackages = await actor.getDefaultPackages(dfxVersion);
+        if (!config.dependencies) {
+            config.dependencies = {};
+        }
+        if (deps) {
+            config.dependencies = deps;
+        }
+        for (let [name, version] of defaultPackages) {
+            config.dependencies[name] = { name, version };
+        }
+        writeConfig(config, configFile);
+        await installAll({ verbose: true });
+    }
+    console.log(chalk.green('mops.toml has been created'));
+}

package/dist/commands/install-all.d.ts

@@ -0,0 +1,4 @@
+export declare function installAll({ verbose, silent }?: {
+    verbose?: boolean | undefined;
+    silent?: boolean | undefined;
+}): Promise<void>;

package/dist/commands/install-all.js

@@ -0,0 +1,29 @@
+import chalk from 'chalk';
+import logUpdate from 'log-update';
+import { checkConfigFile, readConfig } from '../mops.js';
+import { install } from './install.js';
+import { installFromGithub } from '../vessel.js';
+export async function installAll({ verbose = false, silent = false } = {}) {
+    if (!checkConfigFile()) {
+        return;
+    }
+    let config = readConfig();
+    let deps = Object.values(config.dependencies || {});
+    let devDeps = Object.values(config['dev-dependencies'] || {});
+    let allDeps = [...deps, ...devDeps];
+    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) {
+                return;
+            }
+        }
+    }
+    if (!silent) {
+        logUpdate.clear();
+        console.log(chalk.green('All packages installed'));
+    }
+}

package/dist/commands/install.d.ts

@@ -0,0 +1,5 @@
+export declare function install(pkg: string, version?: string, { verbose, silent, dep }?: {
+    verbose?: boolean | undefined;
+    silent?: boolean | undefined;
+    dep?: boolean | undefined;
+}): Promise<boolean>;