ic-mops 0.32.2 → 0.34.0-0

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.d.ts

@@ -0,0 +1,5 @@
+export declare function checkIntegrity(lock?: 'save' | 'check' | 'ignore'): Promise<void>;
+export declare function getLocalFileHash(fileId: string): string;
+export declare function checkRemote(): Promise<void>;
+export declare function saveLockFile(): Promise<void>;
+export declare function checkLockFile(force?: boolean): Promise<void>;

package/dist/integrity.js

@@ -0,0 +1,155 @@
+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 { resolvePackages } from './resolve-packages.js';
+export async function checkIntegrity(lock) {
+    let force = !!lock;
+    if (!lock) {
+        lock = process.env['CI'] ? 'check' : 'ignore';
+    }
+    if (lock === 'save') {
+        await saveLockFile();
+        await checkLockFile(force);
+    }
+    else if (lock === 'check') {
+        await checkLockFile(force);
+    }
+}
+async function getFileHashesFromRegistry() {
+    let packageIds = await getResolvedMopsPackageIds();
+    let actor = await mainActor();
+    let fileHashesByPackageIds = await actor.getFileHashesByPackageIds(packageIds);
+    return fileHashesByPackageIds;
+}
+async function getResolvedMopsPackageIds() {
+    let resolvedPackages = await resolvePackages();
+    let packageIds = Object.entries(resolvedPackages)
+        .filter(([_, version]) => getDependencyType(version) === 'mops')
+        .map(([name, version]) => `${name}@${version}`);
+    return packageIds;
+}
+// get hash of local file from '.mops' dir by fileId
+export function getLocalFileHash(fileId) {
+    let rootDir = getRootDir();
+    let file = path.join(rootDir, '.mops', fileId);
+    if (!fs.existsSync(file)) {
+        console.error(`Missing file ${fileId} in .mops dir`);
+        process.exit(1);
+    }
+    let fileData = fs.readFileSync(file);
+    return bytesToHex(sha256(fileData));
+}
+function getMopsTomlHash() {
+    return bytesToHex(sha256(fs.readFileSync(getRootDir() + '/mops.toml')));
+}
+// compare hashes of local files with hashes from the registry
+export async function checkRemote() {
+    let fileHashesFromRegistry = await getFileHashesFromRegistry();
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (let [_packageId, fileHashes] of fileHashesFromRegistry) {
+        for (let [fileId, hash] of fileHashes) {
+            let remoteHash = new Uint8Array(hash);
+            let localHash = getLocalFileHash(fileId);
+            if (localHash !== bytesToHex(remoteHash)) {
+                console.error('Integrity check failed.');
+                console.error(`Mismatched hash for ${fileId}: ${localHash} vs ${bytesToHex(remoteHash)}`);
+                process.exit(1);
+            }
+        }
+    }
+}
+export async function saveLockFile() {
+    let rootDir = getRootDir();
+    let lockFile = path.join(rootDir, 'mops.lock');
+    // if lock file exists and mops.toml hasn't changed, don't update it
+    if (fs.existsSync(lockFile)) {
+        let lockFileJson = JSON.parse(fs.readFileSync(lockFile).toString());
+        let mopsTomlHash = getMopsTomlHash();
+        if (mopsTomlHash === lockFileJson.mopsTomlHash) {
+            return;
+        }
+    }
+    let fileHashes = await getFileHashesFromRegistry();
+    let lockFileJson = {
+        version: 1,
+        mopsTomlHash: getMopsTomlHash(),
+        hashes: fileHashes.reduce((acc, [packageId, fileHashes]) => {
+            acc[packageId] = fileHashes.reduce((acc, [fileId, hash]) => {
+                acc[fileId] = bytesToHex(new Uint8Array(hash));
+                return acc;
+            }, {});
+            return acc;
+        }, {}),
+    };
+    fs.writeFileSync(lockFile, JSON.stringify(lockFileJson, null, 2));
+}
+// compare hashes of local files with hashes from the lock file
+export async function checkLockFile(force = false) {
+    let rootDir = getRootDir();
+    let lockFile = path.join(rootDir, 'mops.lock');
+    // check if lock file exists
+    if (!fs.existsSync(lockFile)) {
+        if (force) {
+            console.error('Missing lock file. Run `mops install` to generate it.');
+            process.exit(1);
+        }
+        return;
+    }
+    let lockFileJson = JSON.parse(fs.readFileSync(lockFile).toString());
+    let packageIds = await getResolvedMopsPackageIds();
+    // check lock file version
+    if (lockFileJson.version !== 1) {
+        console.error('Integrity check failed');
+        console.error(`Invalid lock file version: ${lockFileJson.version}. Supported versions: 1`);
+        process.exit(1);
+    }
+    // check mops.toml hash
+    if (lockFileJson.mopsTomlHash !== getMopsTomlHash()) {
+        console.error('Integrity check failed');
+        console.error('Mismatched mops.toml hash');
+        console.error(`Locked hash: ${lockFileJson.mopsTomlHash}`);
+        console.error(`Actual hash: ${getMopsTomlHash()}`);
+        process.exit(1);
+    }
+    // check number of packages
+    if (Object.keys(lockFileJson.hashes).length !== packageIds.length) {
+        console.error('Integrity check failed');
+        console.error(`Mismatched number of resolved packages: ${JSON.stringify(Object.keys(lockFileJson.hashes).length)} vs ${JSON.stringify(packageIds.length)}`);
+        process.exit(1);
+    }
+    // check if resolved packages are in the lock file
+    for (let packageId of packageIds) {
+        if (!(packageId in lockFileJson.hashes)) {
+            console.error('Integrity check failed');
+            console.error(`Missing package ${packageId} in lock file`);
+            process.exit(1);
+        }
+    }
+    for (let [packageId, hashes] of Object.entries(lockFileJson.hashes)) {
+        // check if package is in resolved packages
+        if (!packageIds.includes(packageId)) {
+            console.error('Integrity check failed');
+            console.error(`Package ${packageId} in lock file but not in resolved packages`);
+            process.exit(1);
+        }
+        for (let [fileId, lockedHash] of Object.entries(hashes)) {
+            // check if file belongs to package
+            if (!fileId.startsWith(packageId)) {
+                console.error('Integrity check failed');
+                console.error(`File ${fileId} in lock file does not belong to package ${packageId}`);
+                process.exit(1);
+            }
+            // local file hash vs hash from lock file
+            let localHash = getLocalFileHash(fileId);
+            if (lockedHash !== localHash) {
+                console.error('Integrity check failed');
+                console.error(`Mismatched hash for ${fileId}`);
+                console.error(`Locked hash: ${lockedHash}`);
+                console.error(`Actual hash: ${localHash}`);
+                process.exit(1);
+            }
+        }
+    }
+}

package/dist/mops.d.ts

@@ -3,6 +3,7 @@ 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 { downloadPackageFiles } from './helpers/download-package-files.js';
 export declare let apiVersion: string;
 export declare let globalConfigDir: string;
 export declare let globalCacheDir: string;
@@ -34,3 +35,4 @@ 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 { downloadPackageFiles };

package/dist/mops.js

@@ -9,6 +9,7 @@ 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 { downloadPackageFiles } from './helpers/download-package-files.js';
 if (!global.fetch) {
     global.fetch = fetch;
 }
@@ -292,3 +293,4 @@ export async function checkApiCompatibility() {
     }
     return true;
 }
+export { downloadPackageFiles };

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "0.32.2",
+  "version": "0.34.0-0",
   "type": "module",
   "bin": {
     "mops": "dist/cli.js"
@@ -38,6 +38,7 @@
     "@dfinity/identity-secp256k1": "^0.18.1",
     "@dfinity/principal": "^0.18.1",
     "@iarna/toml": "^2.2.5",
+    "@noble/hashes": "1.3.2",
     "as-table": "^1.0.55",
     "cacheable-request": "10.2.12",
     "camelcase": "^7.0.1",

package/dist/vessel.js

@@ -120,11 +120,11 @@ export const installFromGithub = async (name, repo, { verbose = false, dep = fal
     let dir = formatGithubDir(name, repo);
     let cacheName = `_github/${name}#${branch}` + (commitHash ? `@${commitHash}` : '');
     if (existsSync(dir)) {
-        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (local cache) from Github`);
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (local cache)`);
     }
     else if (isCached(cacheName)) {
         await copyCache(cacheName, dir);
-        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (global cache) from Github`);
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (global cache)`);
     }
     else {
         mkdirSync(dir, { recursive: true });

package/helpers/download-package-files.ts

@@ -0,0 +1,78 @@
+import {mainActor, storageActor} from '../mops.js';
+import {parallel} from '../parallel.js';
+import {Principal} from '@dfinity/principal';
+import {resolveVersion} from './resolve-version.js';
+import {Storage} from '../declarations/storage/storage.did.js';
+
+export async function downloadPackageFiles(pkg: string, version = '', threads = 8, onLoad = (_fileIds: string[], _fileId: string) => {}): Promise<Map<string, string>> {
+	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: string) => {
+		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: string, version: string): Promise<{ storageId: Principal, fileIds: string[] }> {
+	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: string, version: string): Promise<string[]> {
+	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: Storage, fileId: string): Promise<{ path: string, data: Array<number> }> {
+	let fileMetaRes = await storage.getFileMeta(fileId);
+	if ('err' in fileMetaRes) {
+		throw fileMetaRes.err;
+	}
+	let fileMeta = fileMetaRes.ok;
+
+	let data: Array<number> = [];
+	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/helpers/resolve-version.ts

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

package/integrity.ts

@@ -0,0 +1,188 @@
+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 {resolvePackages} from './resolve-packages.js';
+
+type LockFileV1 = {
+	version: 1;
+	mopsTomlHash: string;
+	hashes: Record<string, Record<string, string>>;
+};
+
+export async function checkIntegrity(lock?: 'save' | 'check' | 'ignore') {
+	let force = !!lock;
+
+	if (!lock) {
+		lock = process.env['CI'] ? 'check' : 'ignore';
+	}
+
+	if (lock === 'save') {
+		await saveLockFile();
+		await checkLockFile(force);
+	}
+	else if (lock === 'check') {
+		await checkLockFile(force);
+	}
+}
+
+async function getFileHashesFromRegistry(): Promise<[string, [string, Uint8Array | number[]][]][]> {
+	let packageIds = await getResolvedMopsPackageIds();
+	let actor = await mainActor();
+	let fileHashesByPackageIds = await actor.getFileHashesByPackageIds(packageIds);
+	return fileHashesByPackageIds;
+}
+
+async function getResolvedMopsPackageIds(): Promise<string[]> {
+	let resolvedPackages = await resolvePackages();
+	let packageIds = Object.entries(resolvedPackages)
+		.filter(([_, version]) => getDependencyType(version) === 'mops')
+		.map(([name, version]) => `${name}@${version}`);
+	return packageIds;
+}
+
+// get hash of local file from '.mops' dir by fileId
+export function getLocalFileHash(fileId: string): string {
+	let rootDir = getRootDir();
+	let file = path.join(rootDir, '.mops', fileId);
+	if (!fs.existsSync(file)) {
+		console.error(`Missing file ${fileId} in .mops dir`);
+		process.exit(1);
+	}
+	let fileData = fs.readFileSync(file);
+	return bytesToHex(sha256(fileData));
+}
+
+function getMopsTomlHash(): string {
+	return bytesToHex(sha256(fs.readFileSync(getRootDir() + '/mops.toml')));
+}
+
+// compare hashes of local files with hashes from the registry
+export async function checkRemote() {
+	let fileHashesFromRegistry = await getFileHashesFromRegistry();
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	for (let [_packageId, fileHashes] of fileHashesFromRegistry) {
+		for (let [fileId, hash] of fileHashes) {
+			let remoteHash = new Uint8Array(hash);
+			let localHash = getLocalFileHash(fileId);
+
+			if (localHash !== bytesToHex(remoteHash)) {
+				console.error('Integrity check failed.');
+				console.error(`Mismatched hash for ${fileId}: ${localHash} vs ${bytesToHex(remoteHash)}`);
+				process.exit(1);
+			}
+		}
+	}
+}
+
+export async function saveLockFile() {
+	let rootDir = getRootDir();
+	let lockFile = path.join(rootDir, 'mops.lock');
+
+	// if lock file exists and mops.toml hasn't changed, don't update it
+	if (fs.existsSync(lockFile)) {
+		let lockFileJson: LockFileV1 = JSON.parse(fs.readFileSync(lockFile).toString());
+		let mopsTomlHash = getMopsTomlHash();
+		if (mopsTomlHash === lockFileJson.mopsTomlHash) {
+			return;
+		}
+	}
+
+	let fileHashes = await getFileHashesFromRegistry();
+
+	let lockFileJson: LockFileV1 = {
+		version: 1,
+		mopsTomlHash: getMopsTomlHash(),
+		hashes: fileHashes.reduce((acc, [packageId, fileHashes]) => {
+			acc[packageId] = fileHashes.reduce((acc, [fileId, hash]) => {
+				acc[fileId] = bytesToHex(new Uint8Array(hash));
+				return acc;
+			}, {} as Record<string, string>);
+			return acc;
+		}, {} as Record<string, Record<string, string>>),
+	};
+
+	fs.writeFileSync(lockFile, JSON.stringify(lockFileJson, null, 2));
+}
+
+// compare hashes of local files with hashes from the lock file
+export async function checkLockFile(force = false) {
+	let rootDir = getRootDir();
+	let lockFile = path.join(rootDir, 'mops.lock');
+
+	// check if lock file exists
+	if (!fs.existsSync(lockFile)) {
+		if (force) {
+			console.error('Missing lock file. Run `mops install` to generate it.');
+			process.exit(1);
+		}
+		return;
+	}
+
+	let lockFileJson: LockFileV1 = JSON.parse(fs.readFileSync(lockFile).toString());
+	let packageIds = await getResolvedMopsPackageIds();
+
+	// check lock file version
+	if (lockFileJson.version !== 1) {
+		console.error('Integrity check failed');
+		console.error(`Invalid lock file version: ${lockFileJson.version}. Supported versions: 1`);
+		process.exit(1);
+	}
+
+	// check mops.toml hash
+	if (lockFileJson.mopsTomlHash !== getMopsTomlHash()) {
+		console.error('Integrity check failed');
+		console.error('Mismatched mops.toml hash');
+		console.error(`Locked hash: ${lockFileJson.mopsTomlHash}`);
+		console.error(`Actual hash: ${getMopsTomlHash()}`);
+		process.exit(1);
+	}
+
+	// check number of packages
+	if (Object.keys(lockFileJson.hashes).length !== packageIds.length) {
+		console.error('Integrity check failed');
+		console.error(`Mismatched number of resolved packages: ${JSON.stringify(Object.keys(lockFileJson.hashes).length)} vs ${JSON.stringify(packageIds.length)}`);
+		process.exit(1);
+	}
+
+	// check if resolved packages are in the lock file
+	for (let packageId of packageIds) {
+		if (!(packageId in lockFileJson.hashes)) {
+			console.error('Integrity check failed');
+			console.error(`Missing package ${packageId} in lock file`);
+			process.exit(1);
+		}
+	}
+
+	for (let [packageId, hashes] of Object.entries(lockFileJson.hashes)) {
+
+		// check if package is in resolved packages
+		if (!packageIds.includes(packageId)) {
+			console.error('Integrity check failed');
+			console.error(`Package ${packageId} in lock file but not in resolved packages`);
+			process.exit(1);
+		}
+
+		for (let [fileId, lockedHash] of Object.entries(hashes)) {
+
+			// check if file belongs to package
+			if (!fileId.startsWith(packageId)) {
+				console.error('Integrity check failed');
+				console.error(`File ${fileId} in lock file does not belong to package ${packageId}`);
+				process.exit(1);
+			}
+
+			// local file hash vs hash from lock file
+			let localHash = getLocalFileHash(fileId);
+			if (lockedHash !== localHash) {
+				console.error('Integrity check failed');
+				console.error(`Mismatched hash for ${fileId}`);
+				console.error(`Locked hash: ${lockedHash}`);
+				console.error(`Actual hash: ${localHash}`);
+				process.exit(1);
+			}
+		}
+	}
+}

package/mops.ts

@@ -14,6 +14,7 @@ import {_SERVICE as _STORAGE_SERVICE} from './declarations/storage/storage.did.j
 import {decodeFile} from './pem.js';
 import {Config} from './types.js';
 import {Principal} from '@dfinity/principal';
+import {downloadPackageFiles} from './helpers/download-package-files.js';
 
 
 if (!global.fetch) {
@@ -338,4 +339,6 @@ export async function checkApiCompatibility() {
 		console.log('-'.repeat(50));
 	}
 	return true;
-}
+}
+
+export {downloadPackageFiles};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "0.32.2",
+  "version": "0.34.0-0",
   "type": "module",
   "bin": {
     "mops": "dist/cli.js"
@@ -38,6 +38,7 @@
     "@dfinity/identity-secp256k1": "^0.18.1",
     "@dfinity/principal": "^0.18.1",
     "@iarna/toml": "^2.2.5",
+    "@noble/hashes": "1.3.2",
     "as-table": "^1.0.55",
     "cacheable-request": "10.2.12",
     "camelcase": "^7.0.1",

package/vessel.ts

@@ -154,11 +154,11 @@ export const installFromGithub = async (name: string, repo: string, {verbose = f
 	let cacheName = `_github/${name}#${branch}` + (commitHash ? `@${commitHash}` : '');
 
 	if (existsSync(dir)) {
-		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (local cache) from Github`);
+		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (local cache)`);
 	}
 	else if (isCached(cacheName)) {
 		await copyCache(cacheName, dir);
-		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (global cache) from Github`);
+		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (global cache)`);
 	}
 	else {
 		mkdirSync(dir, {recursive: true});