ic-mops 0.34.3 → 0.35.0

package/declarations/main/main.did.js

@@ -1,19 +1,4 @@
 export const idlFactory = ({ IDL }) => {
-  const TestsChanges = IDL.Record({
-    'addedNames' : IDL.Vec(IDL.Text),
-    'removedNames' : IDL.Vec(IDL.Text),
-  });
-  const DepChange = IDL.Record({
-    'oldVersion' : IDL.Text,
-    'name' : IDL.Text,
-    'newVersion' : IDL.Text,
-  });
-  const PackageChanges__1 = IDL.Record({
-    'tests' : TestsChanges,
-    'deps' : IDL.Vec(DepChange),
-    'notes' : IDL.Text,
-    'devDeps' : IDL.Vec(DepChange),
-  });
   const PublishingId = IDL.Text;
   const Err = IDL.Text;
   const Result = IDL.Variant({ 'ok' : IDL.Null, 'err' : Err });
@@ -133,6 +118,15 @@ export const idlFactory = ({ IDL }) => {
     'sourceFiles' : IDL.Nat,
     'sourceSize' : IDL.Nat,
   });
+  const TestsChanges = IDL.Record({
+    'addedNames' : IDL.Vec(IDL.Text),
+    'removedNames' : IDL.Vec(IDL.Text),
+  });
+  const DepChange = IDL.Record({
+    'oldVersion' : IDL.Text,
+    'name' : IDL.Text,
+    'newVersion' : IDL.Text,
+  });
   const PackageChanges = IDL.Record({
     'tests' : TestsChanges,
     'deps' : IDL.Vec(DepChange),
@@ -250,20 +244,15 @@ export const idlFactory = ({ IDL }) => {
     'license' : IDL.Text,
     'readme' : IDL.Text,
   });
-  const PublishingErr = IDL.Text;
-  const Result_2 = IDL.Variant({ 'ok' : PublishingId, 'err' : PublishingErr });
+  const Result_2 = IDL.Variant({ 'ok' : PublishingId, 'err' : Err });
   const TestStats = IDL.Record({
     'passedNames' : IDL.Vec(IDL.Text),
     'passed' : IDL.Nat,
   });
-  return IDL.Service({
+  const Main = IDL.Service({
     'backup' : IDL.Func([], [], []),
-    'claimAirdrop' : IDL.Func([IDL.Principal], [IDL.Text], []),
     'computeHashesForExistingFiles' : IDL.Func([], [], []),
-    'diff' : IDL.Func([IDL.Text, IDL.Text], [PackageChanges__1], ['query']),
     'finishPublish' : IDL.Func([PublishingId], [Result], []),
-    'getAirdropAmount' : IDL.Func([], [IDL.Nat], ['query']),
-    'getAirdropAmountAll' : IDL.Func([], [IDL.Nat], ['query']),
     'getApiVersion' : IDL.Func([], [Text], ['query']),
     'getBackupCanisterId' : IDL.Func([], [IDL.Principal], ['query']),
     'getDefaultPackages' : IDL.Func(
@@ -356,7 +345,6 @@ export const idlFactory = ({ IDL }) => {
         [],
       ),
     'startPublish' : IDL.Func([PackageConfigV2], [Result_2], []),
-    'takeAirdropSnapshot' : IDL.Func([], [], ['oneway']),
     'transferOwnership' : IDL.Func(
         [PackageName, IDL.Principal],
         [Result_1],
@@ -370,5 +358,6 @@ export const idlFactory = ({ IDL }) => {
     'uploadNotes' : IDL.Func([PublishingId, IDL.Text], [Result], []),
     'uploadTestStats' : IDL.Func([PublishingId, TestStats], [Result], []),
   });
+  return Main;
 };
 export const init = ({ IDL }) => { return []; };

package/dist/bin/mops.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/mops.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../cli.js';

package/dist/cli.js

@@ -2,14 +2,12 @@
 import fs from 'node:fs';
 import { program, Argument, Option } 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, setNetwork, apiVersion, checkConfigFile, getNetworkFile, getIdentity } from './mops.js';
+import { checkApiCompatibility, setNetwork, apiVersion, checkConfigFile, getNetworkFile } from './mops.js';
 import { getNetwork } from './api/network.js';
-import { mainActor } from './api/actors.js';
 import { whoami } from './commands/whoami.js';
 import { installAll } from './commands/install-all.js';
 import { search } from './commands/search.js';
@@ -48,7 +46,7 @@ program
     .description('Install the package and save it to mops.toml')
     .option('--dev')
     .option('--verbose')
-    .addOption(new Option('--lockfile <lockfile>', 'Lockfile action').choices(['save', 'ignore']))
+    .addOption(new Option('--lock <action>', 'Lockfile action').choices(['update', 'ignore']))
     .action(async (pkg, options) => {
     if (!checkConfigFile()) {
         process.exit(1);
@@ -63,7 +61,7 @@ program
     .option('--dev', 'Remove from dev-dependencies instead of dependencies')
     .option('--verbose', 'Show more information')
     .option('--dry-run', 'Do not actually remove anything')
-    .addOption(new Option('--lockfile <lockfile>', 'Lockfile action').choices(['save', 'ignore']))
+    .addOption(new Option('--lock <action>', 'Lockfile action').choices(['update', 'ignore']))
     .action(async (pkg, options) => {
     if (!checkConfigFile()) {
         process.exit(1);
@@ -76,7 +74,7 @@ program
     .alias('i')
     .description('Install all dependencies specified in mops.toml')
     .option('--verbose')
-    .addOption(new Option('--lockfile <lockfile>', 'Lockfile action').choices(['save', 'check', 'ignore']))
+    .addOption(new Option('--lock <action>', 'Lockfile action').choices(['check', 'update', 'ignore']))
     .action(async (pkg, options) => {
     if (!checkConfigFile()) {
         process.exit(1);
@@ -144,7 +142,7 @@ program
     if (!checkConfigFile()) {
         process.exit(1);
     }
-    await installAll({ silent: true, lockfile: 'ignore' });
+    await installAll({ silent: true, lock: 'ignore' });
     let sourcesArr = await sources(options);
     console.log(sourcesArr.join('\n'));
 });
@@ -185,7 +183,7 @@ program
     .addOption(new Option('--mode <mode>', 'Test mode').choices(['interpreter', 'wasi']).default('interpreter'))
     .option('-w, --watch', 'Enable watch mode')
     .action(async (filter, options) => {
-    await installAll({ silent: true, lockfile: 'ignore' });
+    await installAll({ silent: true, lock: 'ignore' });
     await test(filter, options);
 });
 // bench
@@ -198,7 +196,7 @@ program
     // .addOption(new Option('--force-gc', 'Force GC'))
     .addOption(new Option('--verbose', 'Show more information'))
     .action(async (filter, options) => {
-    await installAll({ silent: true, lockfile: 'ignore' });
+    await installAll({ silent: true, lock: 'ignore' });
     await bench(filter, options);
 });
 // template
@@ -254,38 +252,6 @@ program
         await setUserProp(prop, value);
     }
 });
-// temp: airdrop
-program
-    .command('airdrop <check|claim> [canister]')
-    .action(async (sub, canister) => {
-    let identity = await getIdentity();
-    let main = await mainActor(identity);
-    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]')
@@ -297,7 +263,7 @@ program
 program
     .command('sync')
     .description('Add missing packages and remove unused packages')
-    .addOption(new Option('--lockfile <lockfile>', 'Lockfile action').choices(['save', 'ignore']))
+    .addOption(new Option('--lock <action>', 'Lockfile action').choices(['update', 'ignore']))
     .action(async (options) => {
     await sync(options);
 });
@@ -312,7 +278,7 @@ program
 program
     .command('update [pkg]')
     .description('Update dependencies specified in mops.toml')
-    .addOption(new Option('--lockfile <lockfile>', 'Lockfile action').choices(['save', 'ignore']))
+    .addOption(new Option('--lock <action>', 'Lockfile action').choices(['update', 'ignore']))
     .action(async (pkg, options) => {
     await update(pkg, options);
 });

package/dist/commands/add.d.ts

@@ -1,7 +1,7 @@
 type AddOptions = {
     verbose?: boolean;
     dev?: boolean;
-    lockfile?: 'save' | 'ignore';
+    lock?: 'update' | 'ignore';
 };
-export declare function add(name: string, { verbose, dev, lockfile }?: AddOptions, asName?: string): Promise<void>;
+export declare function add(name: string, { verbose, dev, lock }?: AddOptions, asName?: string): Promise<void>;
 export {};

package/dist/commands/add.js

@@ -6,8 +6,9 @@ import { getHighestVersion } from '../api/getHighestVersion.js';
 import { installFromGithub } from '../vessel.js';
 import { install } from './install.js';
 import { notifyInstalls } from '../notify-installs.js';
+import { checkIntegrity } from '../integrity.js';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function add(name, { verbose = false, dev = false, lockfile } = {}, asName) {
+export async function add(name, { verbose = false, dev = false, lock } = {}, asName) {
     if (!checkConfigFile()) {
         return;
     }
@@ -90,10 +91,12 @@ export async function add(name, { verbose = false, dev = false, lockfile } = {},
         throw Error(`Invalid config file: [${depsProp}] not found`);
     }
     writeConfig(config);
-    // logUpdate('Checking integrity...');
+    if (lock !== 'ignore') {
+        logUpdate('Checking integrity...');
+    }
     await Promise.all([
         notifyInstalls(Object.keys(installedPackages)),
-        // checkIntegrity(lockfile),
+        checkIntegrity(lock),
     ]);
     logUpdate.clear();
     console.log(chalk.green('Package installed ') + `${pkgDetails.name} = "${pkgDetails.repo || pkgDetails.path || pkgDetails.version}"`);

package/dist/commands/bench.js

@@ -134,7 +134,7 @@ function startDfx(verbose = false) {
     stopDfx(verbose);
     let dir = path.join(getRootDir(), '.mops/.bench');
     fs.writeFileSync(path.join(dir, 'dfx.json'), JSON.stringify(dfxJson(''), null, 2));
-    execSync('dfx start --background --clean' + (verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['inherit', verbose ? 'inherit' : 'ignore', 'inherit'] });
+    execSync('dfx start --background --clean --artificial-delay 0' + (verbose ? '' : ' -qqqq'), { cwd: dir, stdio: ['inherit', verbose ? 'inherit' : 'ignore', 'inherit'] });
 }
 function stopDfx(verbose = false) {
     let dir = path.join(getRootDir(), '.mops/.bench');

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

@@ -1,7 +1,7 @@
 type InstallAllOptions = {
     verbose?: boolean;
     silent?: boolean;
-    lockfile?: 'save' | 'check' | 'ignore';
+    lock?: 'check' | 'update' | 'ignore';
 };
-export declare function installAll({ verbose, silent, lockfile }?: InstallAllOptions): Promise<void>;
+export declare function installAll({ verbose, silent, lock }?: InstallAllOptions): Promise<void>;
 export {};

package/dist/commands/install-all.js

@@ -5,7 +5,7 @@ import { install } from './install.js';
 import { installFromGithub } from '../vessel.js';
 import { notifyInstalls } from '../notify-installs.js';
 import { checkIntegrity } from '../integrity.js';
-export async function installAll({ verbose = false, silent = false, lockfile } = {}) {
+export async function installAll({ verbose = false, silent = false, lock } = {}) {
     if (!checkConfigFile()) {
         return;
     }
@@ -26,12 +26,12 @@ export async function installAll({ verbose = false, silent = false, lockfile } =
             installedPackages = { ...installedPackages, ...res };
         }
     }
-    if (!silent && lockfile !== 'ignore') {
+    if (!silent && lock !== 'ignore') {
         logUpdate('Checking integrity...');
     }
     await Promise.all([
         notifyInstalls(Object.keys(installedPackages)),
-        checkIntegrity(lockfile),
+        checkIntegrity(lock),
     ]);
     if (!silent) {
         logUpdate.clear();

package/dist/commands/remove.d.ts

@@ -2,7 +2,7 @@ type RemoveOptions = {
     verbose?: boolean;
     dev?: boolean;
     dryRun?: boolean;
-    lockfile?: 'save' | 'ignore';
+    lock?: 'update' | 'ignore';
 };
-export declare function remove(name: string, { dev, verbose, dryRun, lockfile }?: RemoveOptions): Promise<void>;
+export declare function remove(name: string, { dev, verbose, dryRun, lock }?: RemoveOptions): Promise<void>;
 export {};

package/dist/commands/remove.js

@@ -2,8 +2,9 @@ import fs from 'node:fs';
 import { deleteSync } from 'del';
 import chalk from 'chalk';
 import { formatDir, formatGithubDir, checkConfigFile, readConfig, writeConfig } from '../mops.js';
+import { checkIntegrity } from '../integrity.js';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function remove(name, { dev = false, verbose = false, dryRun = false, lockfile } = {}) {
+export async function remove(name, { dev = false, verbose = false, dryRun = false, lock } = {}) {
     if (!checkConfigFile()) {
         return;
     }
@@ -80,6 +81,6 @@ export async function remove(name, { dev = false, verbose = false, dryRun = fals
         delete config['dev-dependencies'][name];
     }
     dryRun || writeConfig(config);
-    // await checkIntegrity(lockfile);
+    await checkIntegrity(lock);
     console.log(chalk.green('Package removed ') + `${name} = "${version}"`);
 }

package/dist/commands/sync.d.ts

@@ -1,5 +1,5 @@
 type SyncOptions = {
-    lockfile?: 'save' | 'ignore';
+    lock?: 'update' | 'ignore';
 };
-export declare function sync({ lockfile }?: SyncOptions): Promise<void>;
+export declare function sync({ lock }?: SyncOptions): Promise<void>;
 export {};

package/dist/commands/sync.js

@@ -6,7 +6,7 @@ import { checkConfigFile, getRootDir, readConfig } from '../mops.js';
 import { add } from './add.js';
 import { remove } from './remove.js';
 import { checkIntegrity } from '../integrity.js';
-export async function sync({ lockfile } = {}) {
+export async function sync({ lock } = {}) {
     if (!checkConfigFile()) {
         return;
     }
@@ -19,14 +19,14 @@ export async function sync({ lockfile } = {}) {
     let devDeps = new Set(Object.keys(config['dev-dependencies'] || {}));
     // add missing packages
     for (let pkg of missing) {
-        await add(pkg, { lockfile: 'ignore' });
+        await add(pkg, { lock: 'ignore' });
     }
     // remove unused packages
     for (let pkg of unused) {
         let dev = devDeps.has(pkg) && !deps.has(pkg);
-        await remove(pkg, { dev, lockfile: 'ignore' });
+        await remove(pkg, { dev, lock: 'ignore' });
     }
-    await checkIntegrity(lockfile);
+    await checkIntegrity(lock);
 }
 let ignore = [
     '**/node_modules/**',

package/dist/commands/toolchain/moc.d.ts

@@ -0,0 +1,4 @@
+export declare let isCached: (version: string) => boolean;
+export declare let download: (version: string, { silent }?: {
+    silent?: boolean | undefined;
+}) => Promise<void>;

package/dist/commands/toolchain/moc.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { globalCacheDir } from '../../mops.js';
+import { downloadGithubRelease } from './toolchain-utils.js';
+let cacheDir = path.join(globalCacheDir, 'moc');
+export let isCached = (version) => {
+    let dir = path.join(cacheDir, version);
+    return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'moc'));
+};
+export let download = async (version, { silent = false } = {}) => {
+    if (process.platform == 'win32') {
+        console.log('Windows is not supported. Please use WSL');
+        process.exit(1);
+    }
+    if (!version) {
+        console.log('version is not defined');
+        process.exit(1);
+    }
+    if (isCached(version)) {
+        return;
+    }
+    let url;
+    if (parseInt(version.replaceAll('.', '')) >= parseInt('0.9.5'.replaceAll('.', ''))) {
+        let platfrom = process.platform == 'darwin' ? 'Darwin' : 'Linux';
+        let arch = process.arch.startsWith('arm') ? 'arm64' : 'x86_64';
+        // currently only x64 binaries are available
+        arch = 'x86_64';
+        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+    }
+    else {
+        let platfrom = process.platform == 'darwin' ? 'macos' : 'linux64';
+        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
+    }
+    silent || console.log(`Downloading ${url}`);
+    await downloadGithubRelease(url, path.join(cacheDir, version));
+};

package/dist/commands/toolchain/mocv.d.ts

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

package/dist/commands/toolchain/mocv.js

@@ -0,0 +1,272 @@
+// @ts-nocheck
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import tar from 'tar';
+import { program } from 'commander';
+import prompts from 'prompts';
+import { Octokit } from 'octokit';
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+if (process.platform == 'win32') {
+    console.log('Windows is not supported. Please use WSL');
+    process.exit(1);
+}
+let zshrc = path.join(os.homedir(), '.zshrc');
+let bashrc = path.join(os.homedir(), '.bashrc');
+let cacheDir = path.join(os.homedir(), '.cache/mocv');
+let curVersionFile = path.join(cacheDir, 'versions/current/version.txt');
+let tmpDir = path.join(cacheDir, '.tmp');
+let file = path.join(tmpDir, 'moc.tar.gz');
+let download = async (version, { silent = false } = {}) => {
+    if (!version) {
+        console.log('version is not defined');
+        process.exit(1);
+    }
+    if (isCached(version)) {
+        return;
+    }
+    let url;
+    if (parseInt(version.replaceAll('.', '')) >= parseInt('0.9.5'.replaceAll('.', ''))) {
+        let platfrom = process.platform == 'darwin' ? 'Darwin' : 'Linux';
+        let arch = process.arch.startsWith('arm') ? 'arm64' : 'x86_64';
+        // currently only x64 binaries are available
+        arch = 'x86_64';
+        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+    }
+    else {
+        let platfrom = process.platform == 'darwin' ? 'macos' : 'linux64';
+        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
+    }
+    silent || console.log(`Downloading ${url}`);
+    let res = await fetch(url);
+    if (res.status !== 200) {
+        console.log(`ERR ${res.status} ${url}`);
+        console.log(`moc version '${version}' not found`);
+        process.exit(1);
+    }
+    let arrayBuffer = await res.arrayBuffer();
+    let buffer = Buffer.from(arrayBuffer);
+    fs.mkdirSync(tmpDir, { recursive: true });
+    fs.writeFileSync(file, buffer);
+    let verDir = path.join(cacheDir, 'versions', version);
+    fs.mkdirSync(verDir, { recursive: true });
+    await tar.extract({
+        file,
+        cwd: verDir,
+    });
+    fs.rmSync(file);
+};
+let isCached = (version) => {
+    let dir = path.join(cacheDir, 'versions', version);
+    return fs.existsSync(path.join(dir, 'moc'))
+        && fs.existsSync(path.join(dir, 'mo-doc'))
+        && fs.existsSync(path.join(dir, 'mo-ide'));
+};
+let setCurrent = (version) => {
+    fs.copySync(path.join(cacheDir, 'versions', version), path.join(cacheDir, 'versions/current'), { recursive: true });
+    fs.writeFileSync(curVersionFile, version);
+};
+let getCurrent = () => {
+    if (fs.existsSync(curVersionFile)) {
+        return fs.readFileSync(curVersionFile).toString();
+    }
+};
+let getLatest = async () => {
+    let releases = await getReleases();
+    return releases[0].tag_name;
+};
+let getReleases = async () => {
+    let octokit = new Octokit;
+    let res = await octokit.request('GET /repos/dfinity/motoko/releases', {
+        per_page: 10,
+        headers: {
+            'X-GitHub-Api-Version': '2022-11-28'
+        }
+    });
+    if (res.status !== 200) {
+        console.log('Releases fetch error');
+        process.exit(1);
+    }
+    return res.data;
+};
+let use = async (version) => {
+    if (version === 'latest') {
+        version = await getLatest();
+    }
+    await download(version);
+    setCurrent(version);
+    console.log(`Selected moc ${version}`);
+    // update github env
+    if (process.env.GITHUB_ENV) {
+        fs.appendFileSync(process.env.GITHUB_ENV, `DFX_MOC_PATH=${path.join(cacheDir, 'versions', version)}/moc\n`);
+    }
+};
+program.name('mocv')
+    .action(async (_, config) => {
+    if (config.args.length) {
+        console.log(`unknown command '${config.args.join(' ')}'`);
+        process.exit(1);
+    }
+    let releases = await getReleases();
+    let versions = releases.map((item) => item.tag_name);
+    let current = getCurrent();
+    let currentIndex = versions.indexOf(current);
+    let res = await prompts({
+        type: 'select',
+        name: 'version',
+        message: 'Select moc version',
+        choices: releases.map((release, i) => {
+            let date = new Date(release.published_at).toLocaleDateString(undefined, { year: 'numeric', month: 'short', day: 'numeric' });
+            return {
+                title: release.tag_name + chalk.gray(`  ${date}${currentIndex === i ? chalk.italic(' (current)') : ''}`),
+                value: release.tag_name,
+            };
+        }),
+        initial: currentIndex == -1 ? 0 : currentIndex,
+    });
+    if (!res.version) {
+        return;
+    }
+    await use(res.version);
+});
+let updateShellConfig = async ({ reset = false, yes = false } = {}) => {
+    let setDfxMocPath = reset || yes;
+    let updatePath = reset || yes;
+    if (!setDfxMocPath) {
+        let res = await prompts({
+            type: 'select',
+            name: 'setDfxMocPath',
+            message: 'Do you want to set DFX_MOC_PATH, so `dfx` will use the current `moc` version?',
+            choices: [
+                {
+                    title: 'Yes',
+                    value: true,
+                },
+                {
+                    title: 'No',
+                    value: false,
+                },
+            ],
+        });
+        setDfxMocPath = res.setDfxMocPath;
+    }
+    if (!updatePath) {
+        let res = await prompts({
+            type: 'select',
+            name: 'updatePath',
+            message: 'Do you want to update PATH, so you can call `moc`, `mo-doc` and `mo-ide` from the terminal?',
+            choices: [
+                {
+                    title: 'Yes',
+                    value: true,
+                },
+                {
+                    title: 'No',
+                    value: false,
+                },
+            ],
+        });
+        updatePath = res.updatePath;
+    }
+    if (!setDfxMocPath && !updatePath) {
+        console.log('Nothing to do');
+        return;
+    }
+    let configFiles = [];
+    if (reset || yes) {
+        configFiles = [bashrc, zshrc];
+    }
+    else {
+        let { configFile } = await prompts({
+            type: 'select',
+            name: 'configFile',
+            message: 'Select your shell config file',
+            choices: [
+                {
+                    title: bashrc,
+                    value: bashrc,
+                },
+                {
+                    title: zshrc,
+                    value: zshrc,
+                },
+            ],
+        });
+        configFiles = [configFile];
+    }
+    for (let configFile of configFiles) {
+        if (!fs.existsSync(configFile)) {
+            console.log(`${configFile} not found`);
+            process.exit(1);
+        }
+        let data = fs.readFileSync(configFile).toString();
+        let setDfxLine = '\nexport DFX_MOC_PATH="$HOME/.cache/mocv/versions/current/moc"';
+        let updatePathLine = '\nPATH="$HOME/.cache/mocv/versions/current:$PATH"';
+        let newLines = [];
+        setDfxMocPath && newLines.push(setDfxLine);
+        updatePath && newLines.push(updatePathLine);
+        let oldLines = [
+            `\nexport DFX_MOC_PATH=${path.join(cacheDir, 'versions/current')}/moc\n`,
+            setDfxLine,
+            updatePathLine,
+        ];
+        for (let oldLine of oldLines) {
+            data = data.replace(oldLine, '');
+        }
+        if (data.endsWith('\n\n')) {
+            data = data.trimEnd() + '\n';
+        }
+        if (!reset) {
+            if (!data.endsWith('\n')) {
+                data += '\n';
+            }
+            for (let newLine of newLines) {
+                data += newLine;
+            }
+            data += '\n';
+        }
+        fs.writeFileSync(configFile, data);
+    }
+    ;
+    console.log('Success!');
+    // console.log(`Run "source ${configFile}" to apply changes`);
+    console.log('Restart terminal to apply changes');
+};
+program.command('init')
+    .description('mocv one time initialization')
+    .option('-y, --yes', 'Skip prompts')
+    .action(async (options) => {
+    updateShellConfig(options);
+});
+program.command('reset')
+    .description('Reset changes made by `mocv init`')
+    .action(async () => {
+    updateShellConfig({ reset: true });
+});
+program.command('use <version>')
+    .description('Set current moc version.\nExample 1: "mocv use 0.8.4"\nExample 2: "mocv use latest"')
+    .action(async (version) => {
+    await use(version);
+});
+program.command('current')
+    .description('Print current moc version')
+    .action(async () => {
+    console.log(getCurrent());
+});
+program.command('bin [version]')
+    .description('Print bin directory')
+    .action(async (version = getCurrent()) => {
+    if (version === 'latest') {
+        version = await getLatest();
+    }
+    if (!version) {
+        console.log('No version selected. Please pass a version arg or run `mocv` or `mocv use <version>`');
+        process.exit(1);
+    }
+    if (!isCached(version)) {
+        await download(version, { silent: true });
+    }
+    console.log(path.join(cacheDir, 'versions', version));
+});
+program.parse();