ic-mops 0.28.0 → 0.29.0-0

package/dist/declarations/bench/bench.did.d.ts

@@ -0,0 +1,24 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+
+export interface BenchResult {
+  'instructions' : bigint,
+  'rts_memory_size' : bigint,
+  'rts_total_allocation' : bigint,
+  'rts_collector_instructions' : bigint,
+  'rts_mutator_instructions' : bigint,
+  'rts_heap_size' : bigint,
+}
+export interface BenchSchema {
+  'cols' : Array<string>,
+  'name' : string,
+  'rows' : Array<string>,
+  'description' : string,
+}
+export interface anon_class_10_1 {
+  'getStats' : ActorMethod<[], BenchResult>,
+  'init' : ActorMethod<[], BenchSchema>,
+  'runCellQuery' : ActorMethod<[bigint, bigint], BenchResult>,
+  'runCellUpdate' : ActorMethod<[bigint, bigint], BenchResult>,
+}
+export interface _SERVICE extends anon_class_10_1 {}

package/dist/declarations/bench/bench.did.js

@@ -0,0 +1,24 @@
+export const idlFactory = ({ IDL }) => {
+  const BenchResult = IDL.Record({
+    'instructions' : IDL.Int,
+    'rts_memory_size' : IDL.Int,
+    'rts_total_allocation' : IDL.Int,
+    'rts_collector_instructions' : IDL.Int,
+    'rts_mutator_instructions' : IDL.Int,
+    'rts_heap_size' : IDL.Int,
+  });
+  const BenchSchema = IDL.Record({
+    'cols' : IDL.Vec(IDL.Text),
+    'name' : IDL.Text,
+    'rows' : IDL.Vec(IDL.Text),
+    'description' : IDL.Text,
+  });
+  const anon_class_10_1 = IDL.Service({
+    'getStats' : IDL.Func([], [BenchResult], ['query']),
+    'init' : IDL.Func([], [BenchSchema], []),
+    'runCellQuery' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], ['query']),
+    'runCellUpdate' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
+  });
+  return anon_class_10_1;
+};
+export const init = ({ IDL }) => { return []; };

package/dist/declarations/bench/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 './bench.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 bench: ActorSubclass<_SERVICE>;

package/dist/declarations/bench/index.js

@@ -0,0 +1,41 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+
+// Imports and re-exports candid interface
+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 ||
+  process.env.BENCH_CANISTER_ID;
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({ ...options.agentOptions });
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      "Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent."
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== "ic") {
+    agent.fetchRootKey().catch((err) => {
+      console.warn(
+        "Unable to fetch root key. Check to ensure that your local replica is running"
+      );
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions,
+  });
+};

package/dist/declarations/main/main.did

@@ -41,6 +41,20 @@ type TestStats =
    passed: nat;
    passedNames: vec text;
  };
+type StreamingToken = blob;
+type StreamingStrategy = variant {
+                           Callback:
+                            record {
+                              callback: StreamingCallback;
+                              token: StreamingToken;
+                            };};
+type StreamingCallbackResponse = 
+ record {
+   body: blob;
+   token: opt StreamingToken;
+ };
+type StreamingCallback = func (StreamingToken) ->
+                          (opt StreamingCallbackResponse) query;
 type StorageStats = 
  record {
    cyclesBalance: nat;
@@ -102,6 +116,22 @@ type Result =
    err: Err;
    ok;
  };
+type Response = 
+ record {
+   body: blob;
+   headers: vec Header;
+   status_code: nat16;
+   streaming_strategy: opt StreamingStrategy;
+   upgrade: opt bool;
+ };
+type Request = 
+ record {
+   body: blob;
+   certificate_version: opt nat16;
+   headers: vec Header;
+   method: text;
+   url: text;
+ };
 type PublishingId = text;
 type PublishingErr = text;
 type PageCount = nat;
@@ -232,6 +262,11 @@ type PackageChanges =
    notes: text;
    tests: TestsChanges;
  };
+type Header = 
+ record {
+   text;
+   text;
+ };
 type FileId = text;
 type Err = text;
 type DownloadsSnapshot__1 = 
@@ -300,6 +335,7 @@ service : {
   getTotalDownloads: () -> (nat) query;
   getTotalPackages: () -> (nat) query;
   getUser: (principal) -> (opt User__1) query;
+  http_request: (Request) -> (Response) query;
   notifyInstall: (PackageName__1, PackageVersion) -> () oneway;
   notifyInstalls: (vec record {
                          PackageName__1;

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

@@ -23,6 +23,7 @@ export interface DownloadsSnapshot__1 {
 }
 export type Err = string;
 export type FileId = string;
+export type Header = [string, string];
 export interface PackageChanges {
   'tests' : TestsChanges,
   'deps' : Array<DepChange>,
@@ -142,6 +143,20 @@ export type PackageVersion = string;
 export type PageCount = bigint;
 export type PublishingErr = string;
 export type PublishingId = string;
+export interface Request {
+  'url' : string,
+  'method' : string,
+  'body' : Uint8Array | number[],
+  'headers' : Array<Header>,
+  'certificate_version' : [] | [number],
+}
+export interface Response {
+  'body' : Uint8Array | number[],
+  'headers' : Array<Header>,
+  'upgrade' : [] | [boolean],
+  'streaming_strategy' : [] | [StreamingStrategy],
+  'status_code' : number,
+}
 export type Result = { 'ok' : null } |
   { 'err' : Err };
 export type Result_1 = { 'ok' : PublishingId } |
@@ -168,6 +183,18 @@ export interface StorageStats {
   'cyclesBalance' : bigint,
   'memorySize' : bigint,
 }
+export type StreamingCallback = ActorMethod<
+  [StreamingToken],
+  [] | [StreamingCallbackResponse]
+>;
+export interface StreamingCallbackResponse {
+  'token' : [] | [StreamingToken],
+  'body' : Uint8Array | number[],
+}
+export type StreamingStrategy = {
+    'Callback' : { 'token' : StreamingToken, 'callback' : StreamingCallback }
+  };
+export type StreamingToken = Uint8Array | number[];
 export interface TestStats { 'passedNames' : Array<string>, 'passed' : bigint }
 export interface TestStats__1 {
   'passedNames' : Array<string>,
@@ -246,6 +273,7 @@ export interface _SERVICE {
   'getTotalDownloads' : ActorMethod<[], bigint>,
   'getTotalPackages' : ActorMethod<[], bigint>,
   'getUser' : ActorMethod<[Principal], [] | [User__1]>,
+  'http_request' : ActorMethod<[Request], Response>,
   'notifyInstall' : ActorMethod<[PackageName__1, PackageVersion], undefined>,
   'notifyInstalls' : ActorMethod<
     [Array<[PackageName__1, PackageVersion]>],

package/dist/declarations/main/main.did.js

@@ -174,6 +174,37 @@ export const idlFactory = ({ IDL }) => {
     'githubVerified' : IDL.Bool,
     'github' : IDL.Text,
   });
+  const Header = IDL.Tuple(IDL.Text, IDL.Text);
+  const Request = IDL.Record({
+    'url' : IDL.Text,
+    'method' : IDL.Text,
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(Header),
+    'certificate_version' : IDL.Opt(IDL.Nat16),
+  });
+  const StreamingToken = IDL.Vec(IDL.Nat8);
+  const StreamingCallbackResponse = IDL.Record({
+    'token' : IDL.Opt(StreamingToken),
+    'body' : IDL.Vec(IDL.Nat8),
+  });
+  const StreamingCallback = IDL.Func(
+      [StreamingToken],
+      [IDL.Opt(StreamingCallbackResponse)],
+      ['query'],
+    );
+  const StreamingStrategy = IDL.Variant({
+    'Callback' : IDL.Record({
+      'token' : StreamingToken,
+      'callback' : StreamingCallback,
+    }),
+  });
+  const Response = IDL.Record({
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(Header),
+    'upgrade' : IDL.Opt(IDL.Bool),
+    'streaming_strategy' : IDL.Opt(StreamingStrategy),
+    'status_code' : IDL.Nat16,
+  });
   const PageCount = IDL.Nat;
   const Result_3 = IDL.Variant({ 'ok' : IDL.Null, 'err' : IDL.Text });
   const Result_2 = IDL.Variant({ 'ok' : FileId, 'err' : Err });
@@ -270,6 +301,7 @@ export const idlFactory = ({ IDL }) => {
     'getTotalDownloads' : IDL.Func([], [IDL.Nat], ['query']),
     'getTotalPackages' : IDL.Func([], [IDL.Nat], ['query']),
     'getUser' : IDL.Func([IDL.Principal], [IDL.Opt(User__1)], ['query']),
+    'http_request' : IDL.Func([Request], [Response], ['query']),
     'notifyInstall' : IDL.Func(
         [PackageName__1, PackageVersion],
         [],

package/dist/helpers/get-dfx-version.d.ts

@@ -0,0 +1 @@
+export declare function getDfxVersion(): string;

package/dist/helpers/get-dfx-version.js

@@ -0,0 +1,9 @@
+import { execSync } from 'node:child_process';
+export function getDfxVersion() {
+    try {
+        let res = execSync('dfx --version').toString();
+        return res.trim().split('dfx ')[1] || '';
+    }
+    catch { }
+    return '';
+}

package/dist/helpers/get-moc-path.d.ts

@@ -0,0 +1 @@
+export declare function getMocPath(): string;

package/dist/helpers/get-moc-path.js

@@ -0,0 +1,11 @@
+import { execSync } from 'node:child_process';
+export function getMocPath() {
+    let mocPath = process.env.DFX_MOC_PATH;
+    if (!mocPath) {
+        mocPath = execSync('dfx cache show').toString().trim() + '/moc';
+    }
+    if (!mocPath) {
+        mocPath = 'moc';
+    }
+    return mocPath;
+}

package/dist/helpers/get-moc-version.d.ts

@@ -0,0 +1 @@
+export declare function getMocVersion(): string;

package/dist/helpers/get-moc-version.js

@@ -0,0 +1,7 @@
+import { execSync } from 'node:child_process';
+import { getMocPath } from './get-moc-path.js';
+export function getMocVersion() {
+    let mocPath = getMocPath();
+    let match = execSync(mocPath).toString().trim().match(/Motoko compiler ([^\s]+) .*/);
+    return match?.[1] || '';
+}

package/dist/mops.d.ts

@@ -21,10 +21,12 @@ 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 | undefined;
-    gitName: string | undefined;
+    org: string;
+    gitName: string;
     branch: 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 readConfig(configFile?: string): Config;
 export declare function writeConfig(config: Config, configFile?: string): void;

package/dist/mops.js

@@ -179,12 +179,21 @@ export async function getHighestVersion(pkgName) {
 }
 export function parseGithubURL(href) {
     const url = new URL(href);
-    const branch = url.hash?.substring(1) || 'master';
+    let branchAndSha = url.hash?.substring(1).split('@');
+    let branch = branchAndSha[0] || 'master';
+    let commitHash = branchAndSha[1] || '';
     let [org, gitName] = url.pathname.split('/').filter(path => !!path);
+    org = org || '';
+    gitName = gitName || '';
     if (gitName?.endsWith('.git')) {
         gitName = gitName.substring(0, gitName.length - 4);
     }
-    return { org, gitName, branch };
+    return { org, gitName, branch, commitHash };
+}
+export async function getGithubCommit(repo, ref) {
+    let res = await fetch(`https://api.github.com/repos/${repo}/commits/${ref}`);
+    let json = await res.json();
+    return json;
 }
 export function getDependencyType(version) {
     if (!version || typeof version !== 'string') {
@@ -244,8 +253,8 @@ export function formatDir(name, version) {
     return path.join(getRootDir(), '.mops', `${name}@${version}`);
 }
 export function formatGithubDir(name, repo) {
-    const { branch } = parseGithubURL(repo);
-    return path.join(getRootDir(), '.mops/_github', `${name}@${branch}`);
+    const { branch, commitHash } = parseGithubURL(repo);
+    return path.join(getRootDir(), '.mops/_github', `${name}#${branch}` + (commitHash ? `@${commitHash}` : ''));
 }
 export function readDfxJson() {
     let dir = process.cwd();

package/dist/notify-installs.js

@@ -1,10 +1,10 @@
-import { mainActor } from './mops.js';
+import { getDependencyType, mainActor } from './mops.js';
 import { resolvePackages } from './resolve-packages.js';
 export async function notifyInstalls(names) {
     let resolvedPackages = await resolvePackages();
     let packages = names.map(name => [name, resolvedPackages[name]]);
     if (packages.length) {
         let actor = await mainActor();
-        await actor.notifyInstalls(packages);
+        await actor.notifyInstalls(packages.filter(([_, version]) => getDependencyType(version) === 'mops'));
     }
 }

package/dist/package.json

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

package/dist/vessel.js

@@ -59,8 +59,8 @@ export const readVesselConfig = async (dir, { cache = true } = {}) => {
     return config;
 };
 export const downloadFromGithub = async (repo, dest, onProgress) => {
-    const { branch, org, gitName } = parseGithubURL(repo);
-    const zipFile = `https://github.com/${org}/${gitName}/archive/${branch}.zip`;
+    const { branch, org, gitName, commitHash } = parseGithubURL(repo);
+    const zipFile = `https://github.com/${org}/${gitName}/archive/${commitHash || branch}.zip`;
     const readStream = got.stream(zipFile);
     const promise = new Promise((resolve, reject) => {
         readStream.on('error', (err) => {
@@ -71,7 +71,7 @@ export const downloadFromGithub = async (repo, dest, onProgress) => {
         });
         readStream.on('response', (response) => {
             if (response.headers.age > 3600) {
-                console.log(chalk.red('Error: ') + 'Failure - response too old');
+                console.error(chalk.red('Error: ') + 'Failure - response too old');
                 readStream.destroy(); // Destroy the stream to prevent hanging resources.
                 reject();
                 return;
@@ -79,7 +79,7 @@ export const downloadFromGithub = async (repo, dest, onProgress) => {
             // Prevent `onError` being called twice.
             readStream.off('error', reject);
             const tmpDir = path.resolve(process.cwd(), '.mops/_tmp/');
-            const tmpFile = path.resolve(tmpDir, `${gitName}@${branch}.zip`);
+            const tmpFile = path.resolve(tmpDir, `${gitName}@${commitHash || branch}.zip`);
             try {
                 mkdirSync(tmpDir, { recursive: true });
                 pipeline(readStream, createWriteStream(tmpFile), (err) => {
@@ -114,20 +114,20 @@ export const downloadFromGithub = async (repo, dest, onProgress) => {
     return promise;
 };
 export const installFromGithub = async (name, repo, { verbose = false, dep = false, silent = false } = {}) => {
-    const { branch } = parseGithubURL(repo);
-    const dir = formatGithubDir(name, repo);
-    const cacheName = `github_${name}@${branch}`;
+    let { branch, commitHash } = parseGithubURL(repo);
+    let dir = formatGithubDir(name, repo);
+    let cacheName = `_github/${name}#${branch}` + (commitHash ? `@${commitHash}` : '');
     if (existsSync(dir)) {
-        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} (already installed) from Github`);
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (local cache) from Github`);
     }
     else if (isCached(cacheName)) {
         await copyCache(cacheName, dir);
-        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} (cache) from Github`);
+        silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (global cache) from Github`);
     }
     else {
         mkdirSync(dir, { recursive: true });
         let progress = (step, total) => {
-            silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} ${progressBar(step, total)}`);
+            silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} ${progressBar(step, total)}`);
         };
         progress(0, 2 * (1024 ** 2));
         try {

package/mops.ts

@@ -210,15 +210,23 @@ export async function getHighestVersion(pkgName: string) {
 
 export function parseGithubURL(href: string) {
 	const url = new URL(href);
-	const branch =  url.hash?.substring(1) || 'master';
-
+	let branchAndSha = url.hash?.substring(1).split('@');
+	let branch = branchAndSha[0] || 'master';
+	let commitHash = branchAndSha[1] || '';
 	let [org, gitName] = url.pathname.split('/').filter(path => !!path);
+	org = org || '';
+	gitName = gitName || '';
 
 	if (gitName?.endsWith('.git')) {
 		gitName = gitName.substring(0, gitName.length - 4);
 	}
+	return {org, gitName, branch, commitHash};
+}
 
-	return {org, gitName, branch};
+export async function getGithubCommit(repo: string, ref: string): Promise<any> {
+	let res = await fetch(`https://api.github.com/repos/${repo}/commits/${ref}`);
+	let json = await res.json();
+	return json;
 }
 
 export function getDependencyType(version: string) {
@@ -289,8 +297,8 @@ export function formatDir(name: string, version: string) {
 }
 
 export function formatGithubDir(name: string, repo: string) {
-	const {branch} = parseGithubURL(repo);
-	return path.join(getRootDir(), '.mops/_github', `${name}@${branch}`);
+	const {branch, commitHash} = parseGithubURL(repo);
+	return path.join(getRootDir(), '.mops/_github', `${name}#${branch}` + (commitHash ? `@${commitHash}` : ''));
 }
 
 export function readDfxJson(): any {

package/notify-installs.ts

@@ -1,4 +1,4 @@
-import {mainActor} from './mops.js';
+import {getDependencyType, mainActor} from './mops.js';
 import {resolvePackages} from './resolve-packages.js';
 
 export async function notifyInstalls(names: string[]) {
@@ -6,6 +6,6 @@ export async function notifyInstalls(names: string[]) {
 	let packages: [string, string][] = names.map(name => [name, resolvedPackages[name] as string]);
 	if (packages.length) {
 		let actor = await mainActor();
-		await actor.notifyInstalls(packages);
+		await actor.notifyInstalls(packages.filter(([_, version]) => getDependencyType(version) === 'mops'));
 	}
 }

package/package.json

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

package/vessel.ts

@@ -83,9 +83,9 @@ export const readVesselConfig = async (dir: string, {cache = true} = {}): Promis
 };
 
 export const downloadFromGithub = async (repo: string, dest: string, onProgress: any) => {
-	const {branch, org, gitName} = parseGithubURL(repo);
+	const {branch, org, gitName, commitHash} = parseGithubURL(repo);
 
-	const zipFile = `https://github.com/${org}/${gitName}/archive/${branch}.zip`;
+	const zipFile = `https://github.com/${org}/${gitName}/archive/${commitHash || branch}.zip`;
 	const readStream = got.stream(zipFile);
 
 	const promise = new Promise((resolve, reject) => {
@@ -99,7 +99,7 @@ export const downloadFromGithub = async (repo: string, dest: string, onProgress:
 
 		readStream.on('response', (response) => {
 			if (response.headers.age > 3600) {
-				console.log(chalk.red('Error: ') +  'Failure - response too old');
+				console.error(chalk.red('Error: ') +  'Failure - response too old');
 				readStream.destroy(); // Destroy the stream to prevent hanging resources.
 				reject();
 				return;
@@ -108,7 +108,7 @@ export const downloadFromGithub = async (repo: string, dest: string, onProgress:
 			// Prevent `onError` being called twice.
 			readStream.off('error', reject);
 			const tmpDir = path.resolve(process.cwd(), '.mops/_tmp/');
-			const tmpFile = path.resolve(tmpDir, `${gitName}@${branch}.zip`);
+			const tmpFile = path.resolve(tmpDir, `${gitName}@${commitHash || branch}.zip`);
 
 			try {
 				mkdirSync(tmpDir, {recursive: true});
@@ -147,22 +147,22 @@ export const downloadFromGithub = async (repo: string, dest: string, onProgress:
 };
 
 export const installFromGithub = async (name: string, repo: string, {verbose = false, dep = false, silent = false} = {}) => {
-	const {branch} = parseGithubURL(repo);
-	const dir = formatGithubDir(name, repo);
-	const cacheName = `github_${name}@${branch}`;
+	let {branch, commitHash} = parseGithubURL(repo);
+	let dir = formatGithubDir(name, repo);
+	let cacheName = `_github/${name}#${branch}` + (commitHash ? `@${commitHash}` : '');
 
 	if (existsSync(dir)) {
-		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} (already installed) from Github`);
+		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (local cache) from Github`);
 	}
 	else if (isCached(cacheName)) {
 		await copyCache(cacheName, dir);
-		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} (cache) from Github`);
+		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} (global cache) from Github`);
 	}
 	else {
 		mkdirSync(dir, {recursive: true});
 
 		let progress = (step: number, total: number) => {
-			silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${name}@${branch} ${progressBar(step, total)}`);
+			silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${repo} ${progressBar(step, total)}`);
 		};
 
 		progress(0, 2 * (1024 ** 2));