ic-mops 0.33.0 → 0.34.0

package/dist/cli.js

@@ -7,7 +7,9 @@ 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 { checkApiCompatibility, setNetwork, apiVersion, checkConfigFile, getNetworkFile, getIdentity } 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';
@@ -24,7 +26,10 @@ import { outdated } from './commands/outdated.js';
 import { update } from './commands/update.js';
 import { bench } from './commands/bench.js';
 import { transferOwnership } from './commands/transfer-ownership.js';
-// import {docs} from './commands/docs.js';
+let networkFile = getNetworkFile();
+if (fs.existsSync(networkFile)) {
+    globalThis.MOPS_NETWORK = fs.readFileSync(networkFile).toString() || 'ic';
+}
 program.name('mops');
 // --version
 let packageJson = JSON.parse(fs.readFileSync(new URL('package.json', import.meta.url)).toString());
@@ -119,7 +124,7 @@ program
     .alias('gn')
     .description('Get network')
     .action(async () => {
-    console.log(getNetwork().network);
+    console.log(getNetwork());
 });
 // import-identity
 program
@@ -247,11 +252,12 @@ program
         await setUserProp(prop, value);
     }
 });
-// airdrop
+// temp: airdrop
 program
     .command('airdrop <check|claim> [canister]')
     .action(async (sub, canister) => {
-    let main = await mainActor(true);
+    let identity = await getIdentity();
+    let main = await mainActor(identity);
     if (sub === 'check') {
         let amount = await main.getAirdropAmount();
         if (amount === 0n) {

package/dist/commands/add.js

@@ -1,7 +1,8 @@
 import path from 'node:path';
 import chalk from 'chalk';
 import logUpdate from 'log-update';
-import { checkConfigFile, getGithubCommit, getHighestVersion, parseGithubURL, readConfig, writeConfig } from '../mops.js';
+import { checkConfigFile, getGithubCommit, parseGithubURL, readConfig, writeConfig } from '../mops.js';
+import { getHighestVersion } from '../api/getHighestVersion.js';
 import { installFromGithub } from '../vessel.js';
 import { install } from './install.js';
 import { notifyInstalls } from '../notify-installs.js';

package/dist/commands/available-updates.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { mainActor } from '../mops.js';
+import { mainActor } from '../api/actors.js';
 // [pkg, oldVersion, newVersion]
 export async function getAvailableUpdates(config, pkg) {
     let deps = Object.values(config.dependencies || {});

package/dist/commands/init.js

@@ -3,7 +3,8 @@ import path from 'node:path';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import chalk from 'chalk';
 import prompts from 'prompts';
-import { checkApiCompatibility, mainActor, writeConfig } from '../mops.js';
+import { checkApiCompatibility, writeConfig } from '../mops.js';
+import { mainActor } from '../api/actors.js';
 import { installAll } from './install-all.js';
 import { readVesselConfig } from '../vessel.js';
 import { template } from './template.js';

package/dist/commands/install.js

@@ -2,10 +2,13 @@ import path from 'node:path';
 import fs from 'node:fs';
 import logUpdate from 'log-update';
 import chalk from 'chalk';
-import { checkConfigFile, formatDir, getHighestVersion, mainActor, progressBar, readConfig, storageActor } from '../mops.js';
+import { checkConfigFile, formatDir, progressBar, readConfig } from '../mops.js';
+import { getHighestVersion } from '../api/getHighestVersion.js';
+import { storageActor } from '../api/actors.js';
 import { parallel } from '../parallel.js';
 import { installFromGithub } from '../vessel.js';
 import { addCache, copyCache, isCached } from '../cache.js';
+import { downloadFile, getPackageFilesInfo } from '../api/downloadPackageFiles.js';
 export async function install(pkg, version = '', { verbose = false, silent = false, dep = false } = {}) {
     if (!checkConfigFile()) {
         return false;
@@ -27,7 +30,6 @@ export async function install(pkg, version = '', { verbose = false, silent = fal
         version = versionRes.ok;
     }
     let dir = formatDir(pkg, version);
-    let actor = await mainActor();
     let alreadyInstalled = false;
     // already installed
     if (fs.existsSync(dir)) {
@@ -41,53 +43,30 @@ export async function install(pkg, version = '', { verbose = false, silent = fal
     }
     // download
     else {
-        let [packageDetailsRes, filesIdsRes] = await Promise.all([
-            actor.getPackageDetails(pkg, version),
-            actor.getFileIds(pkg, version),
-        ]);
-        if ('err' in packageDetailsRes) {
-            console.log(chalk.red('Error: ') + packageDetailsRes.err);
-            return false;
-        }
-        let packageDetails = packageDetailsRes.ok;
-        if ('err' in filesIdsRes) {
-            console.log(chalk.red('Error: ') + filesIdsRes.err);
-            return false;
-        }
-        let filesIds = filesIdsRes.ok;
-        total = filesIds.length + 2;
-        let storage = await storageActor(packageDetails.publication.storage);
-        // download files
-        let filesData = new Map;
         let threads = 16;
         // GitHub Actions fails with "fetch failed" if there are multiple concurrent actions
         if (process.env.GITHUB_ENV) {
             threads = 4;
         }
-        await parallel(threads, filesIds, async (fileId) => {
-            let fileMetaRes = await storage.getFileMeta(fileId);
-            if ('err' in fileMetaRes) {
-                console.log(chalk.red('ERR: ') + fileMetaRes.err);
-                return;
+        try {
+            let { storageId, fileIds } = await getPackageFilesInfo(pkg, version);
+            total = fileIds.length + 2;
+            let filesData = new Map;
+            let storage = await storageActor(storageId);
+            await parallel(threads, fileIds, async (fileId) => {
+                let { path, data } = await downloadFile(storage, fileId);
+                filesData.set(path, data);
+                progress();
+            });
+            // write files to disk
+            for (let [filePath, data] of filesData.entries()) {
+                fs.mkdirSync(path.join(dir, path.dirname(filePath)), { recursive: true });
+                fs.writeFileSync(path.join(dir, filePath), Buffer.from(data));
             }
-            let fileMeta = fileMetaRes.ok;
-            let buffer = Buffer.from([]);
-            for (let i = 0n; i < fileMeta.chunkCount; i++) {
-                let chunkRes = await storage.downloadChunk(fileId, i);
-                if ('err' in chunkRes) {
-                    console.log(chalk.red('ERR: ') + chunkRes.err);
-                    return;
-                }
-                let chunk = chunkRes.ok;
-                buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
-            }
-            filesData.set(fileMeta.path, buffer);
-            progress();
-        });
-        // write files to disk
-        for (let [filePath, buffer] of filesData.entries()) {
-            fs.mkdirSync(path.join(dir, path.dirname(filePath)), { recursive: true });
-            fs.writeFileSync(path.join(dir, filePath), buffer);
+        }
+        catch (err) {
+            console.error(chalk.red('Error: ') + err);
+            return false;
         }
         // add to cache
         await addCache(`${pkg}@${version}`, dir);

package/dist/commands/publish.js

@@ -7,7 +7,8 @@ import { minimatch } from 'minimatch';
 import prompts from 'prompts';
 import { fromMarkdown } from 'mdast-util-from-markdown';
 import { toMarkdown } from 'mdast-util-to-markdown';
-import { checkConfigFile, getRootDir, mainActor, progressBar, readConfig } from '../mops.js';
+import { checkConfigFile, getIdentity, getRootDir, progressBar, readConfig } from '../mops.js';
+import { mainActor } from '../api/actors.js';
 import { parallel } from '../parallel.js';
 import { docs } from './docs.js';
 import { testWithReporter } from './test/test.js';
@@ -238,7 +239,8 @@ export async function publish(options = {}) {
         logUpdate(`Uploading files ${progressBar(step, total)}`);
     }
     // upload config
-    let actor = await mainActor(true);
+    let identity = await getIdentity();
+    let actor = await mainActor(identity);
     progress();
     let publishing = await actor.startPublish(backendPkgConfig);
     if ('err' in publishing) {

package/dist/commands/search.js

@@ -1,10 +1,9 @@
 import asTable from 'as-table';
 import chalk from 'chalk';
-import { mainActor } from '../mops.js';
+import { mainActor } from '../api/actors.js';
 export async function search(text) {
     let actor = await mainActor();
-    let res = await actor.search(text, [], []);
-    let packages = res[0];
+    let [packages, _pageCount] = await actor.search(text, [], []);
     if (!packages.length) {
         console.log('Packages not found');
         return;

package/dist/commands/transfer-ownership.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { checkConfigFile, mainActor, readConfig } from '../mops.js';
+import { checkConfigFile, getIdentity, readConfig } from '../mops.js';
+import { mainActor } from '../api/actors.js';
 import { Principal } from '@dfinity/principal';
 import prompts from 'prompts';
 export async function transferOwnership(toPrincipal) {
@@ -24,7 +25,8 @@ export async function transferOwnership(toPrincipal) {
     if (!confirm) {
         return;
     }
-    let actor = await mainActor(true);
+    let identity = await getIdentity();
+    let actor = await mainActor(identity);
     let res = await actor.transferOwnership(config.package?.name || '', principal);
     if ('ok' in res) {
         console.log(chalk.green('Success!'));

package/dist/commands/user.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { getIdentity, mainActor } from '../mops.js';
+import { getIdentity } from '../mops.js';
+import { mainActor } from '../api/actors.js';
 export async function getUserProp(prop) {
     let actor = await mainActor();
     let identity = await getIdentity();
@@ -12,7 +13,8 @@ export async function getUserProp(prop) {
     console.log(res[0]?.[prop] || '');
 }
 export async function setUserProp(prop, value) {
-    let actor = await mainActor(true);
+    let identity = await getIdentity();
+    let actor = await mainActor(identity);
     let res = await actor.setUserProp(prop, value);
     if ('ok' in res) {
         console.log(chalk.green('Success!'));

package/dist/helpers/download-package-files.d.ts

@@ -0,0 +1,12 @@
+import { Principal } from '@dfinity/principal';
+import { Storage } from '../declarations/storage/storage.did.js';
+export declare function downloadPackageFiles(pkg: string, version?: string, threads?: number, onLoad?: (_fileIds: string[], _fileId: string) => void): Promise<Map<string, string>>;
+export declare function getPackageFilesInfo(pkg: string, version: string): Promise<{
+    storageId: Principal;
+    fileIds: string[];
+}>;
+export declare function getFileIds(pkg: string, version: string): Promise<string[]>;
+export declare function downloadFile(storage: Storage, fileId: string): Promise<{
+    path: string;
+    data: Array<number>;
+}>;

package/dist/helpers/download-package-files.js

@@ -0,0 +1,62 @@
+import { mainActor, storageActor } from '../mops.js';
+import { parallel } from '../parallel.js';
+import { resolveVersion } from './resolve-version.js';
+export async function downloadPackageFiles(pkg, version = '', threads = 8, onLoad = (_fileIds, _fileId) => { }) {
+    version = await resolveVersion(pkg, version);
+    let { storageId, fileIds } = await getPackageFilesInfo(pkg, version);
+    let storage = await storageActor(storageId);
+    let filesData = new Map;
+    await parallel(threads, fileIds, async (fileId) => {
+        let { path, data } = await downloadFile(storage, fileId);
+        filesData.set(path, data);
+        onLoad(fileIds, fileId);
+    });
+    return filesData;
+}
+// get package files meta
+export async function getPackageFilesInfo(pkg, version) {
+    let actor = await mainActor();
+    let [packageDetailsRes, fileIds] = await Promise.all([
+        actor.getPackageDetails(pkg, version),
+        getFileIds(pkg, version),
+    ]);
+    if ('err' in packageDetailsRes) {
+        throw packageDetailsRes.err;
+    }
+    let packageDetails = packageDetailsRes.ok;
+    return {
+        storageId: packageDetails.publication.storage,
+        fileIds,
+    };
+}
+// get package files ids
+export async function getFileIds(pkg, version) {
+    let actor = await mainActor();
+    let fileIdsRes = await actor.getFileIds(pkg, version);
+    if ('err' in fileIdsRes) {
+        throw fileIdsRes.err;
+    }
+    let filesIds = fileIdsRes.ok;
+    return filesIds;
+}
+// download single file
+export async function downloadFile(storage, fileId) {
+    let fileMetaRes = await storage.getFileMeta(fileId);
+    if ('err' in fileMetaRes) {
+        throw fileMetaRes.err;
+    }
+    let fileMeta = fileMetaRes.ok;
+    let data = [];
+    for (let i = 0n; i < fileMeta.chunkCount; i++) {
+        let chunkRes = await storage.downloadChunk(fileId, i);
+        if ('err' in chunkRes) {
+            throw chunkRes.err;
+        }
+        let chunk = chunkRes.ok;
+        data = [...data, ...chunk];
+    }
+    return {
+        path: fileMeta.path,
+        data: data,
+    };
+}

package/dist/helpers/resolve-version.d.ts

@@ -0,0 +1 @@
+export declare function resolveVersion(pkg: string, version?: string): Promise<string>;

package/dist/helpers/resolve-version.js

@@ -0,0 +1,11 @@
+import { getHighestVersion } from '../mops.js';
+export async function resolveVersion(pkg, version = '') {
+    if (!version) {
+        let versionRes = await getHighestVersion(pkg);
+        if ('err' in versionRes) {
+            throw versionRes.err;
+        }
+        version = versionRes.ok;
+    }
+    return version;
+}

package/dist/integrity.js

@@ -2,7 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { sha256 } from '@noble/hashes/sha256';
 import { bytesToHex } from '@noble/hashes/utils';
-import { getDependencyType, getRootDir, mainActor } from './mops.js';
+import { getDependencyType, getRootDir } from './mops.js';
+import { mainActor } from './api/actors.js';
 import { resolvePackages } from './resolve-packages.js';
 export async function checkIntegrity(lock) {
     let force = !!lock;

package/dist/mops.d.ts

@@ -1,25 +1,18 @@
 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';
+import { mainActor, storageActor } from './api/actors.js';
+import { getNetwork } from './api/network.js';
+import { getHighestVersion } from './api/getHighestVersion.js';
 export declare let apiVersion: string;
 export declare let globalConfigDir: string;
 export declare let globalCacheDir: string;
+export declare function getNetworkFile(): string | URL;
 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;
     gitName: string;
@@ -27,10 +20,11 @@ export declare function parseGithubURL(href: string): {
     commitHash: string;
 };
 export declare function getGithubCommit(repo: string, ref: string): Promise<any>;
-export declare function getDependencyType(version: string): "mops" | "github" | "local";
+export declare function getDependencyType(version: string): "local" | "mops" | "github";
 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>;
+export { getNetwork, mainActor, storageActor, getHighestVersion, };

package/dist/mops.js

@@ -1,26 +1,19 @@
 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';
+import { mainActor, storageActor } from './api/actors.js';
+import { getNetwork } from './api/network.js';
+import { getHighestVersion } from './api/getHighestVersion.js';
 if (!global.fetch) {
     global.fetch = fetch;
 }
 // (!) make changes in pair with backend
 export let apiVersion = '1.2';
-let networkFile = '';
-try {
-    networkFile = new URL('./network.txt', import.meta.url);
-}
-catch {
-    networkFile = path.join(__dirname, 'network.txt');
-}
 export let globalConfigDir = '';
 export let globalCacheDir = '';
 // OS specific dirs
@@ -69,35 +62,18 @@ if (fs.existsSync(oldGlobalConfigDir) && !fs.existsSync(globalCacheDir)) {
     });
     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',
-        };
+export function getNetworkFile() {
+    let networkFile = '';
+    try {
+        networkFile = new URL('./network.txt', import.meta.url);
     }
-    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',
-        };
+    catch {
+        networkFile = path.join(__dirname, 'network.txt');
     }
+    return networkFile;
+}
+export function setNetwork(network) {
+    fs.writeFileSync(getNetworkFile(), network);
 }
 export let getIdentity = async () => {
     let identityPem = path.resolve(globalConfigDir, 'identity.pem');
@@ -115,35 +91,6 @@ export let getIdentity = async () => {
     }
     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 '';
@@ -173,10 +120,6 @@ 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);
     let branchAndSha = url.hash?.substring(1).split('@');
@@ -292,3 +235,5 @@ export async function checkApiCompatibility() {
     }
     return true;
 }
+// compatibility with older versions
+export { getNetwork, mainActor, storageActor, getHighestVersion, };

package/dist/notify-installs.js

@@ -1,4 +1,5 @@
-import { getDependencyType, mainActor } from './mops.js';
+import { getDependencyType } from './mops.js';
+import { mainActor } from './api/actors.js';
 import { resolvePackages } from './resolve-packages.js';
 export async function notifyInstalls(names) {
     let resolvedPackages = await resolvePackages();

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "type": "module",
   "bin": {
     "mops": "dist/cli.js"

package/integrity.ts

@@ -2,7 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import {sha256} from '@noble/hashes/sha256';
 import {bytesToHex} from '@noble/hashes/utils';
-import {getDependencyType, getRootDir, mainActor} from './mops.js';
+import {getDependencyType, getRootDir} from './mops.js';
+import {mainActor} from './api/actors.js';
 import {resolvePackages} from './resolve-packages.js';
 
 type LockFileV1 = {