ic-mops 0.19.1 → 0.20.1

package/commands/{remove.js → remove.ts}

@@ -1,15 +1,15 @@
-import {checkConfigFile, readConfig, writeConfig} from '../mops.js';
-import fs from 'fs';
-import del from 'del';
+import fs from 'node:fs';
+import {deleteSync} from 'del';
 import chalk from 'chalk';
-import {formatDir, formatGithubDir} from '../mops.js';
+import {formatDir, formatGithubDir, checkConfigFile, readConfig, writeConfig} from '../mops.js';
+import {Config, Dependency} from '../types.js';
 
-export async function remove(name, {dev, verbose, dryRun} = {}) {
+export async function remove(name: string, {dev = false, verbose = false, dryRun = false} = {}) {
 	if (!checkConfigFile()) {
 		return;
 	}
 
-	function getTransitiveDependencies(config, exceptPkgId) {
+	function getTransitiveDependencies(config: Config, exceptPkgId: string) {
 		let deps = Object.values(config.dependencies || {});
 		let devDeps = Object.values(config['dev-dependencies'] || {});
 		return [...deps, ...devDeps]
@@ -21,15 +21,21 @@ export async function remove(name, {dev, verbose, dryRun} = {}) {
 			}).flat();
 	}
 
-	function getTransitiveDependenciesOf(name, version, repo) {
-		let pkgDir = repo ? formatGithubDir(name, repo) : formatDir(name, version);
+	function getTransitiveDependenciesOf(name: string, version: string | undefined, repo?: string) {
+		let pkgDir = '';
+		if (repo) {
+			pkgDir = formatGithubDir(name, repo);
+		}
+		else if (version) {
+			pkgDir = formatDir(name, version);
+		}
 		let configFile = pkgDir + '/mops.toml';
 		if (!fs.existsSync(configFile)) {
 			verbose && console.log('no config', configFile);
 			return [];
 		}
 		let config = readConfig(configFile);
-		let deps = Object.values(config.dependencies || {}).map((dep) => {
+		let deps: Dependency[] = Object.values(config.dependencies || {}).map((dep) => {
 			return [dep, ...getTransitiveDependenciesOf(dep.name, dep.version)];
 		}).flat();
 		return deps;
@@ -37,6 +43,7 @@ export async function remove(name, {dev, verbose, dryRun} = {}) {
 
 	let config = readConfig();
 	let deps = dev ? config['dev-dependencies'] : config.dependencies;
+	deps = deps || {};
 	let pkgDetails = deps[name];
 
 	if (!pkgDetails) {
@@ -66,22 +73,22 @@ export async function remove(name, {dev, verbose, dryRun} = {}) {
 		if (dep.repo) {
 			pkgDir = formatGithubDir(dep.name, dep.repo);
 		}
-		else {
+		else if (dep.version) {
 			pkgDir = formatDir(dep.name, dep.version);
 		}
-		if (fs.existsSync(pkgDir)) {
-			dryRun || del.sync([`${pkgDir}`]);
+		if (pkgDir && fs.existsSync(pkgDir)) {
+			dryRun || deleteSync([`${pkgDir}`]);
 			verbose && console.log(`Removed local cache ${pkgDir}`);
 		}
 	}
 
 	// remove from config
-	if (dev) {
-		delete config['dev-dependencies'][name];
-	}
-	else {
+	if (!dev && config.dependencies) {
 		delete config.dependencies[name];
 	}
+	if (dev && config['dev-dependencies']) {
+		delete config['dev-dependencies'][name];
+	}
 	dryRun || writeConfig(config);
 
 	console.log(chalk.green('Package removed ') + `${name} = "${version}"`);

package/commands/{search.js → search.ts}

@@ -2,7 +2,7 @@ import asTable from 'as-table';
 import chalk from 'chalk';
 import {mainActor} from '../mops.js';
 
-export async function search(text) {
+export async function search(text: string) {
 	let actor = await mainActor();
 	let res = await actor.search(text, [], []);
 	let packages = res[0];
@@ -12,7 +12,7 @@ export async function search(text) {
 		return;
 	}
 
-	let ellipsis = (text, max) => {
+	let ellipsis = (text: string, max: number) => {
 		if (text.length <= max) {
 			return text;
 		}

package/commands/self-update.ts

@@ -0,0 +1,6 @@
+import child_process from 'node:child_process';
+
+export function selfUpdate({detached = false} = {}) {
+	console.log('Updating mops CLI...');
+	child_process.spawn('npm i ic-mops -g', {stdio: 'inherit', detached});
+}

package/commands/{sources.js → sources.ts}

@@ -1,21 +1,22 @@
-import path from 'path';
-import fs from 'fs';
+import path from 'node:path';
+import fs from 'node:fs';
 import chalk from 'chalk';
 import {checkConfigFile, formatDir, formatGithubDir, parseGithubURL, readConfig} from '../mops.js';
-import {readVesselConfig} from '../vessel.js';
+import {VesselConfig, readVesselConfig} from '../vessel.js';
+import {Config, Dependency} from '../types.js';
 
 // TODO: resolve conflicts
-export async function sources({verbose} = {}) {
+export async function sources({verbose = false} = {}) {
 	if (!checkConfigFile()) {
 		return [];
 	}
 
-	let packages = {};
-	let versions = {};
+	let packages: Record<string, Dependency & {isRoot: boolean}> = {};
+	let versions: Record<string, string[]> = {};
 
-	let compareVersions = (a, b) => {
-		let ap = a.split('.').map(x => x |0);
-		let bp = b.split('.').map(x => x |0);
+	let compareVersions = (a: string = '0.0.0', b: string = '0.0.0') => {
+		let ap = a.split('.').map((x: string) => parseInt(x)) as [number, number, number];
+		let bp = b.split('.').map((x: string) => parseInt(x)) as [number, number, number];
 		if (ap[0] - bp[0]) {
 			return Math.sign(ap[0] - bp[0]);
 		}
@@ -30,7 +31,7 @@ export async function sources({verbose} = {}) {
 
 	const gitVerRegex = new RegExp(/v(\d{1,2}\.\d{1,2}\.\d{1,2})(-.*)?$/);
 
-	const compareGitVersions = (repoA, repoB) => {
+	const compareGitVersions = (repoA: string, repoB: string) => {
 		const {branch: a} = parseGithubURL(repoA);
 		const {branch: b} = parseGithubURL(repoB);
 
@@ -45,7 +46,7 @@ export async function sources({verbose} = {}) {
 		}
 	};
 
-	let collectDeps = async (config, isRoot = false) => {
+	let collectDeps = async (config: Config | VesselConfig, isRoot = false) => {
 		let allDeps = [...Object.values(config.dependencies || {})];
 		if (isRoot) {
 			allDeps = [...allDeps, ...Object.values(config['dev-dependencies'] || {})];
@@ -57,13 +58,15 @@ export async function sources({verbose} = {}) {
 			if (
 				isRoot
 				|| !packages[name]
-				|| !packages[name].isRoot
+				|| !packages[name]?.isRoot
 				&& (
-					repo && packages[name].repo && compareGitVersions(packages[name].repo, repo) === -1
-					|| compareVersions(packages[name].version, version) === -1)
+					repo && packages[name]?.repo && compareGitVersions(packages[name]?.repo || '', repo) === -1
+					|| compareVersions(packages[name]?.version, version) === -1)
 			) {
-				packages[name] = pkgDetails;
-				packages[name].isRoot = isRoot;
+				packages[name] = {
+					...pkgDetails,
+					isRoot,
+				};
 			}
 
 			let nestedConfig;
@@ -72,12 +75,12 @@ export async function sources({verbose} = {}) {
 				const dir = formatGithubDir(name, repo);
 				nestedConfig = await readVesselConfig(dir) || {};
 			}
-			else if (!pkgDetails.path) {
-				const dir = formatDir(name, version) + '/mops.toml';
-				nestedConfig = readConfig(dir);
+			else if (!pkgDetails.path && version) {
+				const file = formatDir(name, version) + '/mops.toml';
+				nestedConfig = readConfig(file);
 			}
 
-			if (!pkgDetails.path) {
+			if (nestedConfig && !pkgDetails.path) {
 				await collectDeps(nestedConfig);
 			}
 
@@ -87,10 +90,10 @@ export async function sources({verbose} = {}) {
 
 			if (repo) {
 				const {branch} = parseGithubURL(repo);
-				versions[name].push(branch);
+				versions[name]?.push(branch);
 			}
-			else {
-				versions[name].push(version);
+			else if (version) {
+				versions[name]?.push(version);
 			}
 		}
 	};
@@ -117,9 +120,12 @@ export async function sources({verbose} = {}) {
 		else if (pkg.repo) {
 			pkgDir = path.relative(process.cwd(), formatGithubDir(name, pkg.repo));
 		}
-		else {
+		else if (pkg.version) {
 			pkgDir = path.relative(process.cwd(), formatDir(name, pkg.version));
 		}
+		else {
+			return;
+		}
 
 		// append baseDir
 		let pkgBaseDir;

package/commands/{template.js → template.ts}

@@ -1,5 +1,5 @@
-import fs from 'fs';
-import path from 'path';
+import fs from 'node:fs';
+import path from 'node:path';
 import chalk from 'chalk';
 import prompts from 'prompts';
 import {getRootDir} from '../mops.js';

package/commands/{test.js → test.ts}

@@ -1,11 +1,11 @@
-import {spawn, execSync} from 'child_process';
+import {spawn, execSync, ChildProcessWithoutNullStreams} from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
 import chalk from 'chalk';
-import glob from 'glob';
+import {globSync} from 'glob';
 import chokidar from 'chokidar';
 import debounce from 'debounce';
-import path from 'path';
-import fs from 'fs';
-import os from 'os';
 
 import {MMF1} from './mmf1.js';
 import {sources} from './sources.js';
@@ -65,9 +65,9 @@ let mocPath = process.env.DFX_MOC_PATH;
 export async function runAll(filter = '') {
 	let start = Date.now();
 	let rootDir = getRootDir();
-	let files = [];
-	let libFiles = glob.sync('**/test?(s)/lib.mo', globConfig);
-	if (libFiles.length) {
+	let files: string[] = [];
+	let libFiles = globSync('**/test?(s)/lib.mo', globConfig);
+	if (libFiles[0]) {
 		files = [libFiles[0]];
 	}
 	else {
@@ -75,7 +75,7 @@ export async function runAll(filter = '') {
 		if (filter) {
 			globStr = `**/test?(s)/**/*${filter}*.mo`;
 		}
-		files = glob.sync(path.join(rootDir, globStr), globConfig);
+		files = globSync(path.join(rootDir, globStr), globConfig);
 	}
 	if (!files.length) {
 		if (filter) {
@@ -107,7 +107,11 @@ export async function runAll(filter = '') {
 
 	let i = 0;
 
-	await parallel(os.cpus().length, files, async (file) => {
+	await parallel(os.cpus().length, files, async (file: string) => {
+		if (!mocPath) {
+			mocPath = 'moc';
+		}
+
 		let mmf = new MMF1('store');
 
 		let wasiMode = fs.readFileSync(file, 'utf8').startsWith('// @testmode wasi');
@@ -165,12 +169,12 @@ export async function runAll(filter = '') {
 	return failed === 0;
 }
 
-function absToRel(p) {
+function absToRel(p: string) {
 	let rootDir = getRootDir();
 	return path.relative(rootDir, path.resolve(p));
 }
 
-function pipeMMF(proc, mmf) {
+function pipeMMF(proc: ChildProcessWithoutNullStreams, mmf: MMF1) {
 	return new Promise((resolve) => {
 		// stdout
 		proc.stdout.on('data', (data) => {
@@ -184,9 +188,9 @@ function pipeMMF(proc, mmf) {
 
 		// stderr
 		proc.stderr.on('data', (data) => {
-			let text = data.toString().trim();
+			let text: string = data.toString().trim();
 			let failedLine = '';
-			text = text.replace(/([\w+._/-]+):(\d+).(\d+)(-\d+.\d+)/g, (m0, m1, m2, m3) => {
+			text = text.replace(/([\w+._/-]+):(\d+).(\d+)(-\d+.\d+)/g, (_m0, m1: string, m2: string, m3: string) => {
 				// change absolute file path to relative
 				// change :line:col-line:col to :line:col to work in vscode
 				let res = `${absToRel(m1)}:${m2}:${m3}`;
@@ -197,14 +201,15 @@ function pipeMMF(proc, mmf) {
 
 				// show failed line
 				let content = fs.readFileSync(m1);
-				let lines = content.toString().split('\n');
+				let lines = content.toString().split('\n') || [];
 				failedLine += chalk.dim`\n   ...`;
-				if (m2 - 2 >= 0) {
-					failedLine += chalk.dim`\n   ${+m2 - 1}\t| ${lines[m2 - 2].replaceAll('\t', '  ')}`;
+				let lineBefore = lines[+m2 - 2];
+				if (lineBefore) {
+					failedLine += chalk.dim`\n   ${+m2 - 1}\t| ${lineBefore.replaceAll('\t', '  ')}`;
 				}
-				failedLine += `\n${chalk.redBright`->`} ${m2}\t| ${lines[m2 - 1].replaceAll('\t', '  ')}`;
+				failedLine += `\n${chalk.redBright`->`} ${m2}\t| ${lines[+m2 - 1]?.replaceAll('\t', '  ')}`;
 				if (lines.length > +m2) {
-					failedLine += chalk.dim`\n   ${+m2 + 1}\t| ${lines[m2].replaceAll('\t', '  ')}`;
+					failedLine += chalk.dim`\n   ${+m2 + 1}\t| ${lines[+m2]?.replaceAll('\t', '  ')}`;
 				}
 				failedLine += chalk.dim`\n   ...`;
 				return res;

package/commands/{user.js → user.ts}

@@ -1,14 +1,19 @@
 import chalk from 'chalk';
 import {getIdentity, mainActor} from '../mops.js';
 
-export async function getUserProp(prop) {
+export async function getUserProp(prop: string) {
 	let actor = await mainActor();
 	let identity = await getIdentity();
+	if (!identity) {
+		console.log(chalk.red('Error: ') + 'No identity found');
+		process.exit(1);
+	}
 	let res = await actor.getUser(identity.getPrincipal());
+	// @ts-ignore
 	console.log(res[0]?.[prop] || '');
 }
 
-export async function setUserProp(prop, value) {
+export async function setUserProp(prop: string, value: string) {
 	let actor = await mainActor(true);
 	let res = await actor.setUserProp(prop, value);
 	if ('ok' in res) {

package/declarations/main/index.js

@@ -39,5 +39,3 @@ export const createActor = (canisterId, options = {}) => {
     ...options.actorOptions,
   });
 };
-
-export const main = createActor(canisterId);

package/declarations/main/main.did

@@ -185,7 +185,6 @@ service : {
   finishPublish: (PublishingId) -> (Result);
   getAirdropAmount: () -> (nat) query;
   getAirdropAmountAll: () -> (nat) query;
-  getAllPackages: (nat, nat) -> (vec PackageSummary, PageCount) query;
   getApiVersion: () -> (Text) query;
   getDefaultPackages: (text) -> (vec record {
                                        PackageName__1;
@@ -201,6 +200,10 @@ service : {
   getMostDownloadedPackagesIn7Days: () -> (vec PackageSummary) query;
   getNewPackages: () -> (vec PackageSummary) query;
   getPackageDetails: (PackageName__1, Ver) -> (Result_4) query;
+  getPackagesByCategory: () -> (vec record {
+                                      text;
+                                      vec PackageSummary;
+                                    }) query;
   getRecentlyUpdatedPackages: () -> (vec PackageSummary) query;
   getStoragesStats: () -> (vec record {
                                  StorageId;

package/declarations/main/main.did.d.ts

@@ -151,10 +151,6 @@ export interface _SERVICE {
   'finishPublish' : ActorMethod<[PublishingId], Result>,
   'getAirdropAmount' : ActorMethod<[], bigint>,
   'getAirdropAmountAll' : ActorMethod<[], bigint>,
-  'getAllPackages' : ActorMethod<
-    [bigint, bigint],
-    [Array<PackageSummary>, PageCount]
-  >,
   'getApiVersion' : ActorMethod<[], Text>,
   'getDefaultPackages' : ActorMethod<
     [string],
@@ -174,6 +170,10 @@ export interface _SERVICE {
   'getMostDownloadedPackagesIn7Days' : ActorMethod<[], Array<PackageSummary>>,
   'getNewPackages' : ActorMethod<[], Array<PackageSummary>>,
   'getPackageDetails' : ActorMethod<[PackageName__1, Ver], Result_4>,
+  'getPackagesByCategory' : ActorMethod<
+    [],
+    Array<[string, Array<PackageSummary>]>
+  >,
   'getRecentlyUpdatedPackages' : ActorMethod<[], Array<PackageSummary>>,
   'getStoragesStats' : ActorMethod<[], Array<[StorageId, StorageStats]>>,
   'getTotalDownloads' : ActorMethod<[], bigint>,

package/declarations/main/main.did.js

@@ -2,6 +2,20 @@ export const idlFactory = ({ IDL }) => {
   const PublishingId = IDL.Text;
   const Err = IDL.Text;
   const Result = IDL.Variant({ 'ok' : IDL.Null, 'err' : Err });
+  const Text = IDL.Text;
+  const PackageName__1 = IDL.Text;
+  const Version = IDL.Text;
+  const PackageId = IDL.Text;
+  const Time = IDL.Int;
+  const DownloadsSnapshot__1 = IDL.Record({
+    'startTime' : Time,
+    'endTime' : Time,
+    'downloads' : IDL.Nat,
+  });
+  const Ver = IDL.Text;
+  const FileId = IDL.Text;
+  const Result_6 = IDL.Variant({ 'ok' : IDL.Vec(FileId), 'err' : Err });
+  const Result_5 = IDL.Variant({ 'ok' : Ver, 'err' : Err });
   const User = IDL.Record({
     'id' : IDL.Principal,
     'emailVerified' : IDL.Bool,
@@ -39,7 +53,6 @@ export const idlFactory = ({ IDL }) => {
     'license' : IDL.Text,
     'readme' : IDL.Text,
   });
-  const Time = IDL.Int;
   const PackagePublication = IDL.Record({
     'storage' : IDL.Principal,
     'time' : Time,
@@ -54,20 +67,6 @@ export const idlFactory = ({ IDL }) => {
     'config' : PackageConfigV2__1,
     'publication' : PackagePublication,
   });
-  const PageCount = IDL.Nat;
-  const Text = IDL.Text;
-  const PackageName__1 = IDL.Text;
-  const Version = IDL.Text;
-  const PackageId = IDL.Text;
-  const DownloadsSnapshot__1 = IDL.Record({
-    'startTime' : Time,
-    'endTime' : Time,
-    'downloads' : IDL.Nat,
-  });
-  const Ver = IDL.Text;
-  const FileId = IDL.Text;
-  const Result_6 = IDL.Variant({ 'ok' : IDL.Vec(FileId), 'err' : Err });
-  const Result_5 = IDL.Variant({ 'ok' : Ver, 'err' : Err });
   const PackageSummary__1 = IDL.Record({
     'ownerInfo' : User,
     'owner' : IDL.Principal,
@@ -115,6 +114,7 @@ export const idlFactory = ({ IDL }) => {
     'githubVerified' : IDL.Bool,
     'github' : IDL.Text,
   });
+  const PageCount = IDL.Nat;
   const Result_3 = IDL.Variant({ 'ok' : IDL.Null, 'err' : IDL.Text });
   const Result_2 = IDL.Variant({ 'ok' : FileId, 'err' : Err });
   const PackageConfigV2 = IDL.Record({
@@ -142,11 +142,6 @@ export const idlFactory = ({ IDL }) => {
     'finishPublish' : IDL.Func([PublishingId], [Result], []),
     'getAirdropAmount' : IDL.Func([], [IDL.Nat], ['query']),
     'getAirdropAmountAll' : IDL.Func([], [IDL.Nat], ['query']),
-    'getAllPackages' : IDL.Func(
-        [IDL.Nat, IDL.Nat],
-        [IDL.Vec(PackageSummary), PageCount],
-        ['query'],
-      ),
     'getApiVersion' : IDL.Func([], [Text], ['query']),
     'getDefaultPackages' : IDL.Func(
         [IDL.Text],
@@ -181,6 +176,11 @@ export const idlFactory = ({ IDL }) => {
         [Result_4],
         ['query'],
       ),
+    'getPackagesByCategory' : IDL.Func(
+        [],
+        [IDL.Vec(IDL.Tuple(IDL.Text, IDL.Vec(PackageSummary)))],
+        ['query'],
+      ),
     'getRecentlyUpdatedPackages' : IDL.Func(
         [],
         [IDL.Vec(PackageSummary)],

package/declarations/storage/index.d.ts

@@ -0,0 +1,50 @@
+import type {
+  ActorSubclass,
+  HttpAgentOptions,
+  ActorConfig,
+  Agent,
+} from "@dfinity/agent";
+import type { Principal } from "@dfinity/principal";
+import type { IDL } from "@dfinity/candid";
+
+import { _SERVICE } from './storage.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const storage: ActorSubclass<_SERVICE>;

package/declarations/storage/index.js

@@ -3,18 +3,16 @@ import { Actor, HttpAgent } from "@dfinity/agent";
 // Imports and re-exports candid interface
 import { idlFactory } from './storage.did.js';
 export { idlFactory } from './storage.did.js';
-// CANISTER_ID is replaced by webpack based on node environment
-export const canisterId = process.env.STORAGE_CANISTER_ID;
 
 /**
- * 
+ *
  * @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=>{
@@ -29,10 +27,4 @@ export const canisterId = process.env.STORAGE_CANISTER_ID;
     canisterId,
     ...options?.actorOptions,
   });
-};
-  
-/**
- * A ready-to-use agent for the storage canister
- * @type {import("@dfinity/agent").ActorSubclass<import("./storage.did.js")._SERVICE>}
- */
- export const storage = createActor(canisterId);
+};

package/dist/cache.d.ts

@@ -0,0 +1,5 @@
+export declare let isCached: (pkgId: string) => boolean;
+export declare let addCache: (pkgId: string, source: string) => Promise<void>;
+export declare let copyCache: (pkgId: string, dest: string) => Promise<void>;
+export declare let cacheSize: () => Promise<string>;
+export declare let cleanCache: () => Promise<void>;

package/dist/cache.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import ncp from 'ncp';
+import getFolderSize from 'get-folder-size';
+import { globalCacheDir } from './mops.js';
+export let isCached = (pkgId) => {
+    let dir = path.join(globalCacheDir, 'packages', pkgId);
+    return fs.existsSync(dir);
+};
+export let addCache = (pkgId, source) => {
+    let dest = path.join(globalCacheDir, 'packages', pkgId);
+    fs.mkdirSync(dest, { recursive: true });
+    return new Promise((resolve, reject) => {
+        ncp.ncp(source, dest, { stopOnErr: true }, (err) => {
+            if (err) {
+                reject(err);
+            }
+            resolve();
+        });
+    });
+};
+export let copyCache = (pkgId, dest) => {
+    let source = path.join(globalCacheDir, 'packages', pkgId);
+    fs.mkdirSync(dest, { recursive: true });
+    return new Promise((resolve, reject) => {
+        ncp.ncp(source, dest, { stopOnErr: true }, (err) => {
+            if (err) {
+                reject(err);
+            }
+            resolve();
+        });
+    });
+};
+export let cacheSize = async () => {
+    let dir = path.join(globalCacheDir, 'packages');
+    fs.mkdirSync(dir, { recursive: true });
+    let size = await getFolderSize.strict(dir);
+    if (size < 1024 * 1024) {
+        return (size / 1024).toFixed(2) + ' KB';
+    }
+    return (size / 1024 / 1024).toFixed(2) + ' MB';
+};
+export let cleanCache = async () => {
+    let dir = path.join(globalCacheDir, 'packages');
+    fs.rmSync(dir, { recursive: true, force: true });
+};

package/dist/cli.d.ts

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