ic-mops 0.41.1 → 0.42.0

package/commands/toolchain/moc.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import path from 'node:path';
 import fs from 'fs-extra';
 

package/commands/toolchain/pocket-ic.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import path from 'node:path';
 import fs from 'node:fs';
 

package/commands/toolchain/toolchain-utils.ts

@@ -1,4 +1,6 @@
+import process from 'node:process';
 import path from 'node:path';
+import {Buffer} from 'node:buffer';
 import {unzipSync} from 'node:zlib';
 import {chmodSync} from 'node:fs';
 import fs from 'fs-extra';

package/commands/toolchain/wasmtime.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import path from 'node:path';
 import fs from 'fs-extra';
 

package/commands/transfer-ownership.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import chalk from 'chalk';
 import {checkConfigFile, getIdentity, readConfig} from '../mops.js';
 import {mainActor} from '../api/actors.js';

package/commands/user.ts

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import chalk from 'chalk';
 import {getIdentity} from '../mops.js';
 import {mainActor} from '../api/actors.js';

package/declarations/bench/index.js

@@ -4,14 +4,6 @@ import { Actor, HttpAgent } from "@dfinity/agent";
 import { idlFactory } from "./bench.did.js";
 export { idlFactory } from "./bench.did.js";
 
-/* CANISTER_ID is replaced by webpack based on node environment
- * Note: canister environment variable will be standardized as
- * process.env.CANISTER_ID_<CANISTER_NAME_UPPERCASE>
- * beginning in dfx 0.15.0
- */
-export const canisterId =
-  process.env.CANISTER_ID_BENCH;
-
 export const createActor = (canisterId, options = {}) => {
   const agent = options.agent || new HttpAgent({ ...options.agentOptions });
 

package/declarations/storage/storage.did.d.ts

@@ -1,5 +1,6 @@
 import type { Principal } from '@dfinity/principal';
 import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
 
 export type Chunk = Array<number>;
 export type Err = string;
@@ -35,3 +36,5 @@ export interface StorageStats {
   'memorySize' : bigint,
 }
 export interface _SERVICE extends Storage {}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/dist/api/actors.js

@@ -1,6 +1,6 @@
 import { Actor, HttpAgent } from '@dfinity/agent';
-import { idlFactory } from '../declarations/main/index.js';
-import { idlFactory as storageIdlFactory } from '../declarations/storage/index.js';
+import { idlFactory } from '../declarations/main/main.did.js';
+import { idlFactory as storageIdlFactory } from '../declarations/storage/storage.did.js';
 import { getEndpoint } from './network.js';
 import { getNetwork } from './network.js';
 export let mainActor = async (identity) => {

package/dist/cache.d.ts

@@ -1,5 +1,9 @@
-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 getDepCacheDir: (cacheName: string) => string;
+export declare let isDepCached: (cacheName: string) => boolean;
+export declare function getDepCacheName(name: string, version: string): string;
+export declare function getMopsDepCacheName(name: string, version: string): string;
+export declare function getGithubDepCacheName(name: string, repo: string): string;
+export declare let addCache: (cacheName: string, source: string) => Promise<void>;
+export declare let copyCache: (cacheName: string, dest: string) => Promise<void>;
 export declare let cacheSize: () => Promise<string>;
 export declare let cleanCache: () => Promise<void>;

package/dist/cache.js

@@ -2,13 +2,27 @@ 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);
+import { getDependencyType, globalCacheDir, parseGithubURL } from './mops.js';
+export let getDepCacheDir = (cacheName) => {
+    return path.join(globalCacheDir, 'packages', cacheName);
+};
+export let isDepCached = (cacheName) => {
+    let dir = getDepCacheDir(cacheName);
     return fs.existsSync(dir);
 };
-export let addCache = (pkgId, source) => {
-    let dest = path.join(globalCacheDir, 'packages', pkgId);
+export function getDepCacheName(name, version) {
+    let depType = getDependencyType(version);
+    return depType === 'mops' ? getMopsDepCacheName(name, version) : getGithubDepCacheName(name, version);
+}
+export function getMopsDepCacheName(name, version) {
+    return `${name}@${version}`;
+}
+export function getGithubDepCacheName(name, repo) {
+    const { branch, commitHash } = parseGithubURL(repo);
+    return `_github/${name}#${branch}` + (commitHash ? `@${commitHash}` : '');
+}
+export let addCache = (cacheName, source) => {
+    let dest = path.join(globalCacheDir, 'packages', cacheName);
     fs.mkdirSync(dest, { recursive: true });
     return new Promise((resolve, reject) => {
         ncp.ncp(source, dest, { stopOnErr: true }, (err) => {
@@ -19,8 +33,8 @@ export let addCache = (pkgId, source) => {
         });
     });
 };
-export let copyCache = (pkgId, dest) => {
-    let source = path.join(globalCacheDir, 'packages', pkgId);
+export let copyCache = (cacheName, dest) => {
+    let source = path.join(globalCacheDir, 'packages', cacheName);
     fs.mkdirSync(dest, { recursive: true });
     return new Promise((resolve, reject) => {
         ncp.ncp(source, dest, { stopOnErr: true }, (err) => {

package/dist/cli.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import fs from 'node:fs';
 import { Command, Argument, Option } from 'commander';
 import chalk from 'chalk';
@@ -8,7 +9,7 @@ import { sources } from './commands/sources.js';
 import { checkApiCompatibility, setNetwork, apiVersion, checkConfigFile, getNetworkFile, version } from './mops.js';
 import { getNetwork } from './api/network.js';
 import { whoami } from './commands/whoami.js';
-import { installAll } from './commands/install-all.js';
+import { installAll } from './commands/install/install-all.js';
 import { search } from './commands/search.js';
 import { add } from './commands/add.js';
 import { cacheSize, cleanCache } from './cache.js';
@@ -145,7 +146,7 @@ program
     if (!checkConfigFile()) {
         process.exit(1);
     }
-    await installAll({ silent: true, lock: 'ignore' });
+    await installAll({ silent: true, lock: 'ignore', threads: 6 });
     await toolchain.ensureToolchainInited({ strict: false });
     let sourcesArr = await sources(options);
     console.log(sourcesArr.join('\n'));

package/dist/commands/add.js

@@ -1,13 +1,15 @@
+import process from 'node:process';
 import path from 'node:path';
 import chalk from 'chalk';
 import { createLogUpdate } from 'log-update';
 import { checkConfigFile, getGithubCommit, parseGithubURL, readConfig, writeConfig } from '../mops.js';
 import { getHighestVersion } from '../api/getHighestVersion.js';
+import { installMopsDep } from './install/install-mops-dep.js';
 import { installFromGithub } from '../vessel.js';
-import { install } from './install.js';
-import { notifyInstalls } from '../notify-installs.js';
 import { checkIntegrity } from '../integrity.js';
 import { checkRequirements } from '../check-requirements.js';
+import { syncLocalCache } from './install/sync-local-cache.js';
+import { notifyInstalls } from '../notify-installs.js';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function add(name, { verbose = false, dev = false, lock } = {}, asName) {
     if (!checkConfigFile()) {
@@ -72,16 +74,14 @@ export async function add(name, { verbose = false, dev = false, lock } = {}, asN
             version: ver,
         };
     }
-    let installedPackages = {};
     if (pkgDetails.repo) {
         await installFromGithub(pkgDetails.name, pkgDetails.repo, { verbose: verbose });
     }
     else if (!pkgDetails.path) {
-        let res = await install(pkgDetails.name, pkgDetails.version, { verbose: verbose });
+        let res = await installMopsDep(pkgDetails.name, pkgDetails.version, { verbose: verbose });
         if (res === false) {
             return;
         }
-        installedPackages = { ...installedPackages, ...res };
     }
     const depsProp = dev ? 'dev-dependencies' : 'dependencies';
     let deps = config[depsProp];
@@ -96,8 +96,9 @@ export async function add(name, { verbose = false, dev = false, lock } = {}, asN
     if (lock !== 'ignore') {
         logUpdate('Checking integrity...');
     }
+    let installedPackages = await syncLocalCache();
     await Promise.all([
-        notifyInstalls(Object.keys(installedPackages)),
+        notifyInstalls(installedPackages),
         checkIntegrity(lock),
     ]);
     logUpdate.clear();

package/dist/commands/available-updates.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import chalk from 'chalk';
 import { mainActor } from '../api/actors.js';
 // [pkg, oldVersion, newVersion]

package/dist/commands/bench-replica.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import { execSync } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';

package/dist/commands/bench.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import path from 'node:path';
 import fs from 'node:fs';
 import os from 'node:os';

package/dist/commands/bump.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import prompts from 'prompts';
 import chalk from 'chalk';
 import { checkConfigFile, readConfig, writeConfig } from '../mops.js';

package/dist/commands/docs.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';

package/dist/commands/import-identity.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { Buffer } from 'node:buffer';
 import chalk from 'chalk';
 import prompts from 'prompts';
 import { deleteSync } from 'del';

package/dist/commands/init.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import { execSync } from 'node:child_process';
 import path from 'node:path';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
@@ -5,7 +6,7 @@ import chalk from 'chalk';
 import prompts from 'prompts';
 import { checkApiCompatibility, writeConfig } from '../mops.js';
 import { mainActor } from '../api/actors.js';
-import { installAll } from './install-all.js';
+import { installAll } from './install/install-all.js';
 import { readVesselConfig } from '../vessel.js';
 import { template } from './template.js';
 export async function init({ yes = false } = {}) {

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

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

package/dist/commands/install/install-all.js

@@ -0,0 +1,36 @@
+import process from 'node:process';
+import chalk from 'chalk';
+import { createLogUpdate } from 'log-update';
+import { checkConfigFile, readConfig } from '../../mops.js';
+import { checkIntegrity } from '../../integrity.js';
+import { installDeps } from './install-deps.js';
+import { checkRequirements } from '../../check-requirements.js';
+import { syncLocalCache } from './sync-local-cache.js';
+import { notifyInstalls } from '../../notify-installs.js';
+export async function installAll({ verbose = false, silent = false, threads, lock } = {}) {
+    if (!checkConfigFile()) {
+        return;
+    }
+    let config = readConfig();
+    let deps = Object.values(config.dependencies || {});
+    let devDeps = Object.values(config['dev-dependencies'] || {});
+    let allDeps = [...deps, ...devDeps];
+    let res = await installDeps(allDeps, { silent, verbose, threads });
+    if (!res) {
+        return;
+    }
+    let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
+    if (!silent && lock !== 'ignore') {
+        logUpdate('Checking integrity...');
+    }
+    let installedPackages = await syncLocalCache();
+    await Promise.all([
+        notifyInstalls(installedPackages),
+        checkIntegrity(lock),
+    ]);
+    if (!silent) {
+        logUpdate.clear();
+        await checkRequirements();
+        console.log(chalk.green('Packages installed'));
+    }
+}

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

@@ -0,0 +1,8 @@
+import { Dependency } from '../../types.js';
+type InstallDepOptions = {
+    verbose?: boolean;
+    silent?: boolean;
+    threads?: number;
+};
+export declare function installDep(dep: Dependency, { verbose, silent, threads }?: InstallDepOptions, parentPkgPath?: string): Promise<Record<string, string> | false>;
+export {};

package/dist/commands/install/install-dep.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+import { installFromGithub } from '../../vessel.js';
+import { installMopsDep } from './install-mops-dep.js';
+import { installLocalDep } from './install-local-dep.js';
+import { getRootDir } from '../../mops.js';
+// install dependency
+// returns false if failed
+export async function installDep(dep, { verbose, silent, threads } = {}, parentPkgPath) {
+    if (dep.repo) {
+        await installFromGithub(dep.name, dep.repo, { silent, verbose });
+        return {};
+    }
+    else if (dep.path) {
+        let depPath = dep.path;
+        parentPkgPath = parentPkgPath || getRootDir();
+        if (parentPkgPath) {
+            depPath = path.resolve(parentPkgPath, dep.path);
+        }
+        return installLocalDep(dep.name, depPath, { silent, verbose });
+    }
+    else if (dep.version) {
+        return installMopsDep(dep.name, dep.version, { silent, verbose, threads });
+    }
+    return {};
+}

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

@@ -0,0 +1,8 @@
+import { Dependency } from '../../types.js';
+type InstallDepsOptions = {
+    verbose?: boolean;
+    silent?: boolean;
+    threads?: number;
+};
+export declare function installDeps(deps: Dependency[], { verbose, silent, threads }?: InstallDepsOptions, parentPkgPath?: string): Promise<Record<string, string> | false>;
+export {};

package/dist/commands/install/install-deps.js

@@ -0,0 +1,21 @@
+import { installDep } from './install-dep.js';
+// install all dependencies
+// returns actual installed dependencies
+// returns false if failed
+export async function installDeps(deps, { verbose, silent, threads } = {}, parentPkgPath) {
+    let installedDeps = {};
+    let ok = true;
+    for (const dep of deps) {
+        let res = await installDep(dep, { verbose, silent, threads }, parentPkgPath);
+        if (res) {
+            installedDeps = { ...installedDeps, ...res };
+        }
+        else {
+            ok = false;
+        }
+    }
+    if (!ok) {
+        return false;
+    }
+    return installedDeps;
+}

package/dist/commands/install/install-local-dep.d.ts

@@ -0,0 +1,6 @@
+type InstallLocalDepOptions = {
+    verbose?: boolean;
+    silent?: boolean;
+};
+export declare function installLocalDep(pkg: string, pkgPath?: string, { verbose, silent }?: InstallLocalDepOptions): Promise<Record<string, string> | false>;
+export {};

package/dist/commands/install/install-local-dep.js

@@ -0,0 +1,23 @@
+import process from 'node:process';
+import path from 'node:path';
+import { createLogUpdate } from 'log-update';
+import { getRootDir, readConfig } from '../../mops.js';
+import { installDeps } from './install-deps.js';
+// skip install and just find non-local dependencies to install
+// pkgPath should be relative to the current root dir or absolute
+export async function installLocalDep(pkg, pkgPath = '', { verbose, silent } = {}) {
+    if (!silent) {
+        let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
+        logUpdate(`Local dependency ${pkg} = "${pkgPath}"`);
+        if (verbose) {
+            silent || logUpdate.done();
+        }
+        else {
+            logUpdate.clear();
+        }
+    }
+    // install dependencies
+    let dir = path.resolve(getRootDir(), pkgPath);
+    let config = readConfig(path.join(dir, 'mops.toml'));
+    return installDeps(Object.values(config.dependencies || {}), { silent, verbose }, pkgPath);
+}

package/dist/commands/install/install-mops-dep.d.ts

@@ -0,0 +1,8 @@
+type InstallMopsDepOptions = {
+    verbose?: boolean;
+    silent?: boolean;
+    dep?: boolean;
+    threads?: number;
+};
+export declare function installMopsDep(pkg: string, version?: string, { verbose, silent, dep, threads }?: InstallMopsDepOptions): Promise<Record<string, string> | false>;
+export {};

package/dist/commands/install/install-mops-dep.js

@@ -0,0 +1,103 @@
+import process from 'node:process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { Buffer } from 'node:buffer';
+import { createLogUpdate } from 'log-update';
+import chalk from 'chalk';
+import { deleteSync } from 'del';
+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 { getDepCacheDir, getMopsDepCacheName, isDepCached } from '../../cache.js';
+import { downloadFile, getPackageFilesInfo } from '../../api/downloadPackageFiles.js';
+import { installDeps } from './install-deps.js';
+export async function installMopsDep(pkg, version = '', { verbose, silent, dep, threads } = {}) {
+    threads = threads || 12;
+    if (!checkConfigFile()) {
+        return false;
+    }
+    let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
+    // progress
+    let total = Infinity;
+    let step = 0;
+    let progress = () => {
+        step++;
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} ${progressBar(step, total)}`);
+    };
+    progress();
+    if (!version) {
+        let versionRes = await getHighestVersion(pkg);
+        if ('err' in versionRes) {
+            console.log(chalk.red('Error: ') + versionRes.err);
+            return false;
+        }
+        version = versionRes.ok;
+    }
+    let dir = formatDir(pkg, version);
+    let cacheName = getMopsDepCacheName(pkg, version);
+    let cacheDir = getDepCacheDir(cacheName);
+    let alreadyInstalled = false;
+    // already installed
+    if (fs.existsSync(dir)) {
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (local cache)`);
+        alreadyInstalled = true;
+    }
+    // copy from cache
+    else if (isDepCached(cacheName)) {
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (global cache)`);
+    }
+    // download
+    else {
+        // GitHub Actions fails with "fetch failed" if there are multiple concurrent actions
+        if (process.env.GITHUB_ENV) {
+            threads = 4;
+        }
+        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 global cache
+            try {
+                for (let [filePath, data] of filesData.entries()) {
+                    fs.mkdirSync(path.join(cacheDir, path.dirname(filePath)), { recursive: true });
+                    fs.writeFileSync(path.join(cacheDir, filePath), Buffer.from(data));
+                }
+            }
+            catch (err) {
+                console.error(chalk.red('Error: ') + err);
+                deleteSync([cacheDir], { force: true });
+                return false;
+            }
+        }
+        catch (err) {
+            console.error(chalk.red('Error: ') + err);
+            return false;
+        }
+        progress();
+    }
+    if (verbose) {
+        silent || logUpdate.done();
+    }
+    else {
+        logUpdate.clear();
+    }
+    // install dependencies
+    let config = readConfig(path.join(cacheDir, 'mops.toml'));
+    let res = await installDeps(Object.values(config.dependencies || {}), { silent, verbose });
+    if (!res) {
+        return false;
+    }
+    let installedDeps = res;
+    // add self to installed deps
+    if (!alreadyInstalled) {
+        installedDeps = { ...installedDeps, [pkg]: version };
+    }
+    return installedDeps;
+}

package/dist/commands/install/sync-local-cache.d.ts

@@ -0,0 +1,3 @@
+export declare function syncLocalCache({ verbose }?: {
+    verbose?: boolean | undefined;
+}): Promise<Record<string, string>>;

package/dist/commands/install/sync-local-cache.js

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { copyCache, getDepCacheName } from '../../cache.js';
+import { getDependencyType, getRootDir } from '../../mops.js';
+import { resolvePackages } from '../../resolve-packages.js';
+export async function syncLocalCache({ verbose = false } = {}) {
+    let resolvedPackages = await resolvePackages();
+    let rootDir = getRootDir();
+    verbose && console.log('Syncing local cache...');
+    let installedDeps = {};
+    await Promise.all(Object.entries(resolvedPackages).map(([name, value]) => {
+        let depType = getDependencyType(value);
+        if (depType === 'mops' || depType === 'github') {
+            let cacheName = getDepCacheName(name, value);
+            let dest = path.join(rootDir, '.mops', cacheName);
+            if (!fs.existsSync(dest)) {
+                if (depType === 'mops') {
+                    installedDeps[name] = value;
+                }
+                return copyCache(cacheName, path.join(rootDir, '.mops', cacheName));
+            }
+        }
+        return Promise.resolve();
+    }));
+    return installedDeps;
+}

package/dist/commands/publish.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';

package/dist/commands/remove.js

@@ -1,9 +1,11 @@
 import fs from 'node:fs';
 import { deleteSync } from 'del';
 import chalk from 'chalk';
-import { formatDir, formatGithubDir, checkConfigFile, readConfig, writeConfig } from '../mops.js';
+import { checkConfigFile, getRootDir, readConfig, writeConfig } from '../mops.js';
 import { checkIntegrity } from '../integrity.js';
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { getDepCacheDir, getDepCacheName } from '../cache.js';
+import path from 'node:path';
+import { syncLocalCache } from './install/sync-local-cache.js';
 export async function remove(name, { dev = false, verbose = false, dryRun = false, lock } = {}) {
     if (!checkConfigFile()) {
         return;
@@ -20,13 +22,12 @@ export async function remove(name, { dev = false, verbose = false, dryRun = fals
         }).flat();
     }
     function getTransitiveDependenciesOf(name, version, repo) {
-        let pkgDir = '';
-        if (repo) {
-            pkgDir = formatGithubDir(name, repo);
-        }
-        else if (version) {
-            pkgDir = formatDir(name, version);
+        let value = version || repo;
+        if (!value) {
+            return [];
         }
+        let cacheName = getDepCacheName(name, value);
+        let pkgDir = getDepCacheDir(cacheName);
         let configFile = pkgDir + '/mops.toml';
         if (!fs.existsSync(configFile)) {
             verbose && console.log('no config', configFile);
@@ -61,16 +62,11 @@ export async function remove(name, { dev = false, verbose = false, dryRun = fals
             verbose && console.log(`Ignored transitive dependency ${depId} (other deps depend on it)`);
             continue;
         }
-        let pkgDir;
-        if (dep.repo) {
-            pkgDir = formatGithubDir(dep.name, dep.repo);
-        }
-        else if (dep.version) {
-            pkgDir = formatDir(dep.name, dep.version);
-        }
-        if (pkgDir && fs.existsSync(pkgDir)) {
-            dryRun || deleteSync([`${pkgDir}`], { force: true });
-            verbose && console.log(`Removed local cache ${pkgDir}`);
+        let cacheName = getDepCacheName(dep.name, dep.version || dep.repo || '');
+        let localCacheDir = path.join(getRootDir(), '.mops', cacheName);
+        if (localCacheDir && fs.existsSync(localCacheDir)) {
+            dryRun || deleteSync([localCacheDir], { force: true });
+            verbose && console.log(`Removed local cache ${localCacheDir}`);
         }
     }
     // remove from config
@@ -81,6 +77,7 @@ export async function remove(name, { dev = false, verbose = false, dryRun = fals
         delete config['dev-dependencies'][name];
     }
     dryRun || writeConfig(config);
+    await syncLocalCache();
     await checkIntegrity(lock);
     console.log(chalk.green('Package removed ') + `${name} = "${version}"`);
 }

package/dist/commands/search.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import asTable from 'as-table';
 import chalk from 'chalk';
 import { mainActor } from '../api/actors.js';

package/dist/commands/self.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import child_process, { execSync } from 'node:child_process';
 import chalk from 'chalk';
 import { version, globalConfigDir } from '../mops.js';

package/dist/commands/sources.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import path from 'node:path';
 import fs from 'node:fs';
 import { checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConfig } from '../mops.js';

package/dist/commands/sync.js

@@ -1,3 +1,4 @@
+import process from 'node:process';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
 import { globSync } from 'glob';