ic-mops 0.34.4 → 0.36.0

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();

package/dist/commands/toolchain/toolchain-utils.d.ts

@@ -0,0 +1,3 @@
+export declare let downloadGithubRelease: (url: string, dest: string) => Promise<void>;
+export declare let getLatestReleaseTag: (repo: string) => Promise<string | undefined>;
+export declare let getReleases: (repo: string) => Promise<any>;

package/dist/commands/toolchain/toolchain-utils.js

@@ -0,0 +1,56 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import decompress from 'decompress';
+import decompressTarxz from 'decomp-tarxz';
+import { deleteSync } from 'del';
+import { Octokit } from 'octokit';
+import tar from 'tar';
+import { getRootDir } from '../../mops.js';
+export let downloadGithubRelease = async (url, dest) => {
+    let res = await fetch(url);
+    if (res.status !== 200) {
+        console.error(`ERROR ${res.status} ${url}`);
+        process.exit(1);
+    }
+    let arrayBuffer = await res.arrayBuffer();
+    let buffer = Buffer.from(arrayBuffer);
+    let tmpDir = path.join(getRootDir(), '.mops', '_tmp');
+    let archive = path.join(tmpDir, path.basename(url));
+    fs.mkdirSync(tmpDir, { recursive: true });
+    fs.writeFileSync(archive, buffer);
+    fs.mkdirSync(dest, { recursive: true });
+    if (archive.endsWith('.xz')) {
+        await decompress(archive, dest, {
+            strip: 1,
+            plugins: [decompressTarxz()],
+        }).catch(() => {
+            deleteSync([tmpDir]);
+        });
+    }
+    else {
+        await tar.extract({
+            file: archive,
+            cwd: dest,
+        });
+    }
+    deleteSync([tmpDir], { force: true });
+};
+export let getLatestReleaseTag = async (repo) => {
+    let releases = await getReleases(repo);
+    let release = releases.find((release) => !release.prerelease && !release.draft);
+    return release?.tag_name;
+};
+export let getReleases = async (repo) => {
+    let octokit = new Octokit;
+    let res = await octokit.request(`GET /repos/${repo}/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;
+};

package/dist/commands/toolchain/wasmtime.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/wasmtime.js

@@ -0,0 +1,23 @@
+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, 'wasmtime');
+export let isCached = (version) => {
+    let dir = path.join(cacheDir, version);
+    return fs.existsSync(dir) && fs.existsSync(path.join(dir, 'wasmtime'));
+};
+export let download = async (version, { silent = false } = {}) => {
+    if (!version) {
+        console.error('version is not defined');
+        process.exit(1);
+    }
+    if (isCached(version)) {
+        return;
+    }
+    let platfrom = process.platform == 'darwin' ? 'macos' : 'linux';
+    let arch = process.arch.startsWith('arm') ? 'aarch64' : 'x86_64';
+    let url = `https://github.com/bytecodealliance/wasmtime/releases/download/v${version}/wasmtime-v${version}-${arch}-${platfrom}.tar.xz`;
+    silent || console.log(`Downloading ${url}`);
+    await downloadGithubRelease(url, path.join(cacheDir, version));
+};

package/dist/commands/update.d.ts

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

package/dist/commands/update.js

@@ -3,7 +3,7 @@ import { checkConfigFile, getGithubCommit, parseGithubURL, readConfig } from '..
 import { add } from './add.js';
 import { getAvailableUpdates } from './available-updates.js';
 import { checkIntegrity } from '../integrity.js';
-export async function update(pkg, { lockfile } = {}) {
+export async function update(pkg, { lock } = {}) {
     if (!checkConfigFile()) {
         return;
     }
@@ -43,5 +43,5 @@ export async function update(pkg, { lockfile } = {}) {
             await add(`${dep[0]}@${dep[2]}`, { dev });
         }
     }
-    await checkIntegrity(lockfile);
+    await checkIntegrity(lock);
 }

package/dist/declarations/main/main.did

@@ -111,7 +111,7 @@ type Result_3 =
  };
 type Result_2 = 
  variant {
-   err: PublishingErr;
+   err: Err;
    ok: PublishingId;
  };
 type Result_1 = 
@@ -141,7 +141,6 @@ type Request =
    url: text;
  };
 type PublishingId = text;
-type PublishingErr = text;
 type PageCount = nat;
 type PackageVersion = text;
 type PackageSummary__1 = 
@@ -272,13 +271,6 @@ type PackageConfigV2 =
    scripts: vec Script;
    version: text;
  };
-type PackageChanges__1 = 
- record {
-   deps: vec DepChange;
-   devDeps: vec DepChange;
-   notes: text;
-   tests: TestsChanges;
- };
 type PackageChanges = 
  record {
    deps: vec DepChange;
@@ -286,6 +278,71 @@ type PackageChanges =
    notes: text;
    tests: TestsChanges;
  };
+type Main = 
+ service {
+   backup: () -> ();
+   computeHashesForExistingFiles: () -> ();
+   finishPublish: (PublishingId) -> (Result);
+   getApiVersion: () -> (Text) query;
+   getBackupCanisterId: () -> (principal) query;
+   getDefaultPackages: (text) ->
+    (vec record {
+           PackageName;
+           PackageVersion;
+         }) query;
+   getDownloadTrendByPackageId: (PackageId) ->
+    (vec DownloadsSnapshot__1) query;
+   getDownloadTrendByPackageName: (PackageName) ->
+    (vec DownloadsSnapshot__1) query;
+   getFileHashes: (PackageName, PackageVersion) -> (Result_8);
+   getFileHashesByPackageIds: (vec PackageId) ->
+    (vec record {
+           PackageId;
+           vec record {
+                 FileId;
+                 blob;
+               };
+         });
+   getFileIds: (PackageName, PackageVersion) -> (Result_7) query;
+   getHighestSemverBatch:
+    (vec record {
+           PackageName;
+           PackageVersion;
+           SemverPart;
+         }) -> (Result_6) query;
+   getHighestVersion: (PackageName) -> (Result_5) query;
+   getMostDownloadedPackages: () -> (vec PackageSummary) query;
+   getMostDownloadedPackagesIn7Days: () -> (vec PackageSummary) query;
+   getNewPackages: () -> (vec PackageSummary) query;
+   getPackageDetails: (PackageName, PackageVersion) -> (Result_4) query;
+   getPackagesByCategory: () -> (vec record {
+                                       text;
+                                       vec PackageSummary;
+                                     }) query;
+   getRecentlyUpdatedPackages: () -> (vec PackageSummaryWithChanges) query;
+   getStoragesStats: () -> (vec record {
+                                  StorageId;
+                                  StorageStats;
+                                }) query;
+   getTotalDownloads: () -> (nat) query;
+   getTotalPackages: () -> (nat) query;
+   getUser: (principal) -> (opt User__1) query;
+   http_request: (Request) -> (Response) query;
+   notifyInstall: (PackageName, PackageVersion) -> () oneway;
+   notifyInstalls: (vec record {
+                          PackageName;
+                          PackageVersion;
+                        }) -> () oneway;
+   restore: (nat, nat) -> ();
+   search: (Text, opt nat, opt nat) -> (vec PackageSummary, PageCount) query;
+   setUserProp: (text, text) -> (Result_1);
+   startFileUpload: (PublishingId, Text, nat, blob) -> (Result_3);
+   startPublish: (PackageConfigV2) -> (Result_2);
+   transferOwnership: (PackageName, principal) -> (Result_1);
+   uploadFileChunk: (PublishingId, FileId, nat, blob) -> (Result);
+   uploadNotes: (PublishingId, text) -> (Result);
+   uploadTestStats: (PublishingId, TestStats) -> (Result);
+ };
 type Header = 
  record {
    text;
@@ -323,72 +380,4 @@ type DepChange =
    newVersion: text;
    oldVersion: text;
  };
-service : {
-  backup: () -> ();
-  claimAirdrop: (principal) -> (text);
-  computeHashesForExistingFiles: () -> ();
-  diff: (text, text) -> (PackageChanges__1) query;
-  finishPublish: (PublishingId) -> (Result);
-  getAirdropAmount: () -> (nat) query;
-  getAirdropAmountAll: () -> (nat) query;
-  getApiVersion: () -> (Text) query;
-  getBackupCanisterId: () -> (principal) query;
-  getDefaultPackages: (text) ->
-   (vec record {
-          PackageName;
-          PackageVersion;
-        }) query;
-  getDownloadTrendByPackageId: (PackageId) ->
-   (vec DownloadsSnapshot__1) query;
-  getDownloadTrendByPackageName: (PackageName) ->
-   (vec DownloadsSnapshot__1) query;
-  getFileHashes: (PackageName, PackageVersion) -> (Result_8);
-  getFileHashesByPackageIds: (vec PackageId) ->
-   (vec record {
-          PackageId;
-          vec record {
-                FileId;
-                blob;
-              };
-        });
-  getFileIds: (PackageName, PackageVersion) -> (Result_7) query;
-  getHighestSemverBatch:
-   (vec record {
-          PackageName;
-          PackageVersion;
-          SemverPart;
-        }) -> (Result_6) query;
-  getHighestVersion: (PackageName) -> (Result_5) query;
-  getMostDownloadedPackages: () -> (vec PackageSummary) query;
-  getMostDownloadedPackagesIn7Days: () -> (vec PackageSummary) query;
-  getNewPackages: () -> (vec PackageSummary) query;
-  getPackageDetails: (PackageName, PackageVersion) -> (Result_4) query;
-  getPackagesByCategory: () -> (vec record {
-                                      text;
-                                      vec PackageSummary;
-                                    }) query;
-  getRecentlyUpdatedPackages: () -> (vec PackageSummaryWithChanges) query;
-  getStoragesStats: () -> (vec record {
-                                 StorageId;
-                                 StorageStats;
-                               }) query;
-  getTotalDownloads: () -> (nat) query;
-  getTotalPackages: () -> (nat) query;
-  getUser: (principal) -> (opt User__1) query;
-  http_request: (Request) -> (Response) query;
-  notifyInstall: (PackageName, PackageVersion) -> () oneway;
-  notifyInstalls: (vec record {
-                         PackageName;
-                         PackageVersion;
-                       }) -> () oneway;
-  restore: (nat, nat) -> ();
-  search: (Text, opt nat, opt nat) -> (vec PackageSummary, PageCount) query;
-  setUserProp: (text, text) -> (Result_1);
-  startFileUpload: (PublishingId, Text, nat, blob) -> (Result_3);
-  startPublish: (PackageConfigV2) -> (Result_2);
-  takeAirdropSnapshot: () -> () oneway;
-  transferOwnership: (PackageName, principal) -> (Result_1);
-  uploadFileChunk: (PublishingId, FileId, nat, blob) -> (Result);
-  uploadNotes: (PublishingId, text) -> (Result);
-  uploadTestStats: (PublishingId, TestStats) -> (Result);
-}
+service : () -> Main