ic-mops 0.1.4 → 0.1.7

package/cli.js

@@ -11,7 +11,7 @@ import {install} from './commands/install.js';
 import {publish} from './commands/publish.js';
 import {importPem} from './commands/import-identity.js';
 import {sources} from './commands/sources.js';
-import {checkApiCompatibility, getMaxVersion, getNetwork, setNetwork} from './mops.js';
+import {checkApiCompatibility, getHighestVersion, getNetwork, setNetwork} from './mops.js';
 import {whoami} from './commands/whoami.js';
 import {installAll} from './commands/install-all.js';
 import logUpdate from 'log-update';
@@ -64,13 +64,13 @@ program
 			installAll(options);
 		}
 		else {
-			let version = await getMaxVersion(pkg);
+			let version = await getHighestVersion(pkg);
 			await install(pkg, version, {verbose: options.verbose});
 
 			config.dependencies[pkg] = version;
 			wirteConfig(config);
 			logUpdate.clear();
-			console.log(chalk.green('Package installed ') + `${pkg} = '${version}'`);
+			console.log(chalk.green('Package installed ') + `${pkg} = "${version}"`);
 		}
 	});
 

package/commands/import-identity.js

@@ -1,10 +1,15 @@
 import fs from 'fs';
 import chalk from 'chalk';
+import path from 'path';
+import {globalCacheDir} from '../mops.js';
 
 export async function importPem(data) {
 	try {
-		let url = new URL('../identity.pem', import.meta.url);
-		fs.writeFileSync(url, data);
+		if (!fs.existsSync(globalCacheDir)) {
+			fs.mkdirSync(globalCacheDir);
+		}
+		let identityPem = path.resolve(globalCacheDir, 'identity.pem');
+		fs.writeFileSync(identityPem, data);
 		console.log(chalk.green('Success'));
 	}
 	catch (err) {

package/commands/install.js

@@ -1,8 +1,9 @@
 import path from 'path';
 import fs from 'fs';
 import logUpdate from 'log-update';
-import {checkConfigFile, getMaxVersion, mainActor, progressBar, readConfig} from '../mops.js';
+import {checkConfigFile, getHighestVersion, mainActor, progressBar, readConfig, storageActor} from '../mops.js';
 import {parallel} from '../parallel.js';
+import chalk from 'chalk';
 
 export async function install(pkg, version = '', {verbose, silent, dep} = {}) {
 	if (!checkConfigFile()) {
@@ -10,7 +11,7 @@ export async function install(pkg, version = '', {verbose, silent, dep} = {}) {
 	}
 
 	if (!version) {
-		version = await getMaxVersion(pkg);
+		version = await getHighestVersion(pkg);
 	}
 
 	let dir = path.join(process.cwd(), '.mops', `${pkg}@${version}`);
@@ -27,7 +28,9 @@ export async function install(pkg, version = '', {verbose, silent, dep} = {}) {
 		if (!dep) {
 			actor.notifyInstall(pkg, version);
 		}
+		let packageDetails = await actor.getPackageDetails(pkg, version);
 		let filesIds = await actor.getFileIds(pkg, version);
+		let storage = await storageActor(packageDetails.publication.storage);
 
 		// progress
 		let total = filesIds.length + 1;
@@ -40,9 +43,25 @@ export async function install(pkg, version = '', {verbose, silent, dep} = {}) {
 		// download files
 		progress();
 		await parallel(8, filesIds, async (fileId) => {
-			let file = await actor.getFile(fileId);
-			fs.mkdirSync(path.join(dir, path.dirname(file.path)), {recursive: true});
-			fs.writeFileSync(path.join(dir, file.path), Buffer.from(file.content));
+			let fileMetaRes = await storage.getFileMeta(fileId);
+			if (fileMetaRes.err) {
+				console.log(chalk.red('ERR: ') + fileMetaRes.err);
+				return;
+			}
+			let fileMeta = fileMetaRes.ok;
+
+			let chunks = Array(Number(fileMeta.chunkCount));
+			for (let i = 0; i < fileMeta.chunkCount; i++) {
+				let chunkRes = await storage.downloadChunk(fileId, i);
+				if (chunkRes.err) {
+					console.log(chalk.red('ERR: ') + chunkRes.err);
+					return;
+				}
+				chunks[i] = chunkRes.ok;
+			}
+
+			fs.mkdirSync(path.join(dir, path.dirname(fileMeta.path)), {recursive: true});
+			fs.writeFileSync(path.join(dir, fileMeta.path), Buffer.from(chunks.flat()));
 			progress();
 		});
 	}

package/commands/publish.js

@@ -188,8 +188,28 @@ export async function publish() {
 	// upload files
 	await parallel(8, files, async (file) => {
 		progress();
+
+		let chunkSize = 1024 * 1024 + 512 * 1024; // 1.5mb
 		let content = fs.readFileSync(file);
-		await actor.uploadFile(puiblishingId, file, Array.from(content));
+		let chunkCount = Math.ceil(content.length / chunkSize);
+		let firstChunk = Array.from(content.slice(0, chunkSize));
+
+		let res = await actor.startFileUpload(puiblishingId, file, chunkCount, firstChunk);
+		if (res.err) {
+			console.log(chalk.red('Error: ') + res.err);
+			return;
+		}
+		let fileId = res.ok;
+
+		for (let i = 1; i < chunkCount; i++) {
+			let start = i * chunkSize;
+			let chunk = Array.from(content.slice(start, start + chunkSize));
+			let res = await actor.uploadFileChunk(puiblishingId, fileId, i, chunk);
+			if (res.err) {
+				console.log(chalk.red('Error: ') + res.err);
+				return;
+			}
+		}
 	});
 
 	// finish

package/commands/sources.js

@@ -2,7 +2,7 @@ import path from 'path';
 import fs from 'fs';
 import chalk from 'chalk';
 import {install} from './install.js';
-import {getMaxVersion, readConfig} from '../mops.js';
+import {getHighestVersion, readConfig} from '../mops.js';
 
 function rootDir(cwd = process.cwd()) {
 	let configFile = path.join(cwd, 'mops.toml');
@@ -73,7 +73,7 @@ export async function sources({verbose} = {}) {
 			packages['base-unofficial'] = downloadedPackages['base-unofficial'];
 		}
 		else {
-			let version = await getMaxVersion('base-unofficial');
+			let version = await getHighestVersion('base-unofficial');
 			await install('base-unofficial', version, {silent: true, dep: true});
 			packages['base-unofficial'] = version;
 		}

package/commands/uninstall.js

@@ -13,20 +13,20 @@ export async function uninstall(pkg, version) {
 	let pkgDir = path.join(process.cwd(), '.mops', `${pkg}@${version}`);
 
 	if (!fs.existsSync(pkgDir)) {
-		console.log(`No cache to remove ${pkg} = '${version}'`);
+		console.log(`No cache to remove ${pkg} = "${version}"`);
 		return;
 	}
 
 	// don't remove if there are dependents
 	// let dependents = getDependents(pkg, version);
 	// if (dependents.length) {
-	// 	console.log(`Cache left ${pkg} = '${version}' (dependents: ${dependents})`)
+	// 	console.log(`Cache left ${pkg} = "${version}" (dependents: ${dependents})`)
 	// 	return;
 	// }
 
 	del.sync([`${pkgDir}/**`]);
 
-	console.log(chalk.green('Package removed ') + `${pkg} = '${version}'`);
+	console.log(chalk.green('Package removed ') + `${pkg} = "${version}"`);
 
 	// remove dependencies
 	// let text = fs.readFileSync(path.join(pkgDir, 'mops.toml')).toString();

package/commands/whoami.js

@@ -1,9 +1,10 @@
 import chalk from 'chalk';
 import fs from 'fs';
-import {getIdentity} from '../mops.js';
+import path from 'path';
+import {getIdentity, globalCacheDir} from '../mops.js';
 
 export function whoami() {
-	let identityPem = new URL('../identity.pem', import.meta.url);
+	let identityPem = path.resolve(globalCacheDir, 'identity.pem');
 	if (fs.existsSync(identityPem)) {
 		let identity = getIdentity();
 		console.log(identity.getPrincipal().toText());

package/declarations/main/main.did

@@ -1,11 +1,23 @@
 type Version = text;
 type Time = int;
 type Text = text;
+type StorageStats = 
+ record {
+   cyclesBalance: nat;
+   fileCount: nat;
+   memorySize: nat;
+ };
+type StorageId = principal;
 type Script = 
  record {
    name: text;
    value: text;
  };
+type Result_2 = 
+ variant {
+   err: Err;
+   ok: FileId;
+ };
 type Result_1 = 
  variant {
    err: PublishingErr;
@@ -18,29 +30,39 @@ type Result =
  };
 type PublishingId = text;
 type PublishingErr = text;
-type PackageSummary = 
+type PackagePublication = 
+ record {
+   storage: principal;
+   time: Time;
+   user: principal;
+ };
+type PackageName__1 = text;
+type PackageName = text;
+type PackageDetails = 
+ record {
+   config: PackageConfig__1;
+   downloadsInLast30Days: nat;
+   downloadsTotal: nat;
+   owner: principal;
+   publication: PackagePublication;
+ };
+type PackageConfig__1 = 
  record {
    dependencies: vec Dependency;
    description: text;
    dfx: text;
    documentation: text;
    donation: text;
-   downloadsInLast30Days: nat;
-   downloadsTotal: nat;
    homepage: text;
    keywords: vec text;
    license: text;
    moc: text;
    name: PackageName;
-   owner: principal;
    readme: text;
    repository: text;
    scripts: vec Script;
-   updatedAt: Time;
    version: text;
  };
-type PackageName__1 = text;
-type PackageName = text;
 type PackageConfig = 
  record {
    dependencies: vec Dependency;
@@ -59,12 +81,6 @@ type PackageConfig =
    version: text;
  };
 type FileId = text;
-type File = 
- record {
-   content: blob;
-   id: FileId;
-   path: Text;
- };
 type Err = text;
 type Dependency = 
  record {
@@ -74,15 +90,17 @@ type Dependency =
 service : {
   finishPublish: (PublishingId) -> (Result);
   getApiVersion: () -> (Text) query;
-  getConfig: (PackageName__1, Version) -> (PackageConfig) query;
-  getFile: (FileId) -> (File) query;
   getFileIds: (PackageName__1, Version) -> (vec FileId) query;
-  getMaxVersion: (PackageName__1) -> (Version) query;
-  getPackageSummary: (PackageName__1, Version) -> (PackageSummary) query;
-  getReadmeFile: (PackageName__1, Version) -> (File) query;
-  getRecentlyUpdatedPackages: () -> (vec PackageSummary) query;
+  getHighestVersion: (PackageName__1) -> (Version) query;
+  getPackageDetails: (PackageName__1, Version) -> (PackageDetails) query;
+  getRecentlyUpdatedPackages: () -> (vec PackageDetails) query;
+  getStoragesStats: () -> (vec record {
+                                 StorageId;
+                                 StorageStats;
+                               }) query;
   notifyInstall: (PackageName__1, Version) -> () oneway;
-  search: (Text) -> (vec PackageSummary) query;
+  search: (Text) -> (vec PackageDetails) query;
+  startFileUpload: (PublishingId, Text, nat, blob) -> (Result_2);
   startPublish: (PackageConfig) -> (Result_1);
-  uploadFile: (PublishingId, Text, blob) -> (Result);
+  uploadFileChunk: (PublishingId, FileId, nat, blob) -> (Result);
 }

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

@@ -3,11 +3,6 @@ import type { ActorMethod } from '@dfinity/agent';
 
 export interface Dependency { 'name' : PackageName, 'version' : string }
 export type Err = string;
-export interface File {
-  'id' : FileId,
-  'content' : Array<number>,
-  'path' : Text,
-}
 export type FileId = string;
 export interface PackageConfig {
   'dfx' : string,
@@ -25,50 +20,71 @@ export interface PackageConfig {
   'license' : string,
   'readme' : string,
 }
-export type PackageName = string;
-export type PackageName__1 = string;
-export interface PackageSummary {
+export interface PackageConfig__1 {
   'dfx' : string,
   'moc' : string,
   'scripts' : Array<Script>,
-  'owner' : Principal,
   'documentation' : string,
   'name' : PackageName,
   'homepage' : string,
-  'downloadsTotal' : bigint,
-  'downloadsInLast30Days' : bigint,
   'description' : string,
   'version' : string,
   'keywords' : Array<string>,
   'donation' : string,
-  'updatedAt' : Time,
   'repository' : string,
   'dependencies' : Array<Dependency>,
   'license' : string,
   'readme' : string,
 }
+export interface PackageDetails {
+  'owner' : Principal,
+  'downloadsTotal' : bigint,
+  'downloadsInLast30Days' : bigint,
+  'config' : PackageConfig__1,
+  'publication' : PackagePublication,
+}
+export type PackageName = string;
+export type PackageName__1 = string;
+export interface PackagePublication {
+  'storage' : Principal,
+  'time' : Time,
+  'user' : Principal,
+}
 export type PublishingErr = string;
 export type PublishingId = string;
 export type Result = { 'ok' : null } |
   { 'err' : Err };
 export type Result_1 = { 'ok' : PublishingId } |
   { 'err' : PublishingErr };
+export type Result_2 = { 'ok' : FileId } |
+  { 'err' : Err };
 export interface Script { 'value' : string, 'name' : string }
+export type StorageId = Principal;
+export interface StorageStats {
+  'fileCount' : bigint,
+  'cyclesBalance' : bigint,
+  'memorySize' : bigint,
+}
 export type Text = string;
 export type Time = bigint;
 export type Version = string;
 export interface _SERVICE {
   'finishPublish' : ActorMethod<[PublishingId], Result>,
   'getApiVersion' : ActorMethod<[], Text>,
-  'getConfig' : ActorMethod<[PackageName__1, Version], PackageConfig>,
-  'getFile' : ActorMethod<[FileId], File>,
   'getFileIds' : ActorMethod<[PackageName__1, Version], Array<FileId>>,
-  'getMaxVersion' : ActorMethod<[PackageName__1], Version>,
-  'getPackageSummary' : ActorMethod<[PackageName__1, Version], PackageSummary>,
-  'getReadmeFile' : ActorMethod<[PackageName__1, Version], File>,
-  'getRecentlyUpdatedPackages' : ActorMethod<[], Array<PackageSummary>>,
+  'getHighestVersion' : ActorMethod<[PackageName__1], Version>,
+  'getPackageDetails' : ActorMethod<[PackageName__1, Version], PackageDetails>,
+  'getRecentlyUpdatedPackages' : ActorMethod<[], Array<PackageDetails>>,
+  'getStoragesStats' : ActorMethod<[], Array<[StorageId, StorageStats]>>,
   'notifyInstall' : ActorMethod<[PackageName__1, Version], undefined>,
-  'search' : ActorMethod<[Text], Array<PackageSummary>>,
+  'search' : ActorMethod<[Text], Array<PackageDetails>>,
+  'startFileUpload' : ActorMethod<
+    [PublishingId, Text, bigint, Array<number>],
+    Result_2,
+  >,
   'startPublish' : ActorMethod<[PackageConfig], Result_1>,
-  'uploadFile' : ActorMethod<[PublishingId, Text, Array<number>], Result>,
+  'uploadFileChunk' : ActorMethod<
+    [PublishingId, FileId, bigint, Array<number>],
+    Result,
+  >,
 }

package/declarations/main/main.did.js

@@ -5,10 +5,11 @@ export const idlFactory = ({ IDL }) => {
   const Text = IDL.Text;
   const PackageName__1 = IDL.Text;
   const Version = IDL.Text;
+  const FileId = IDL.Text;
   const Script = IDL.Record({ 'value' : IDL.Text, 'name' : IDL.Text });
   const PackageName = IDL.Text;
   const Dependency = IDL.Record({ 'name' : PackageName, 'version' : IDL.Text });
-  const PackageConfig = IDL.Record({
+  const PackageConfig__1 = IDL.Record({
     'dfx' : IDL.Text,
     'moc' : IDL.Text,
     'scripts' : IDL.Vec(Script),
@@ -24,28 +25,37 @@ export const idlFactory = ({ IDL }) => {
     'license' : IDL.Text,
     'readme' : IDL.Text,
   });
-  const FileId = IDL.Text;
-  const File = IDL.Record({
-    'id' : FileId,
-    'content' : IDL.Vec(IDL.Nat8),
-    'path' : Text,
-  });
   const Time = IDL.Int;
-  const PackageSummary = IDL.Record({
+  const PackagePublication = IDL.Record({
+    'storage' : IDL.Principal,
+    'time' : Time,
+    'user' : IDL.Principal,
+  });
+  const PackageDetails = IDL.Record({
+    'owner' : IDL.Principal,
+    'downloadsTotal' : IDL.Nat,
+    'downloadsInLast30Days' : IDL.Nat,
+    'config' : PackageConfig__1,
+    'publication' : PackagePublication,
+  });
+  const StorageId = IDL.Principal;
+  const StorageStats = IDL.Record({
+    'fileCount' : IDL.Nat,
+    'cyclesBalance' : IDL.Nat,
+    'memorySize' : IDL.Nat,
+  });
+  const Result_2 = IDL.Variant({ 'ok' : FileId, 'err' : Err });
+  const PackageConfig = IDL.Record({
     'dfx' : IDL.Text,
     'moc' : IDL.Text,
     'scripts' : IDL.Vec(Script),
-    'owner' : IDL.Principal,
     'documentation' : IDL.Text,
     'name' : PackageName,
     'homepage' : IDL.Text,
-    'downloadsTotal' : IDL.Nat,
-    'downloadsInLast30Days' : IDL.Nat,
     'description' : IDL.Text,
     'version' : IDL.Text,
     'keywords' : IDL.Vec(IDL.Text),
     'donation' : IDL.Text,
-    'updatedAt' : Time,
     'repository' : IDL.Text,
     'dependencies' : IDL.Vec(Dependency),
     'license' : IDL.Text,
@@ -56,34 +66,37 @@ export const idlFactory = ({ IDL }) => {
   return IDL.Service({
     'finishPublish' : IDL.Func([PublishingId], [Result], []),
     'getApiVersion' : IDL.Func([], [Text], ['query']),
-    'getConfig' : IDL.Func(
-        [PackageName__1, Version],
-        [PackageConfig],
-        ['query'],
-      ),
-    'getFile' : IDL.Func([FileId], [File], ['query']),
     'getFileIds' : IDL.Func(
         [PackageName__1, Version],
         [IDL.Vec(FileId)],
         ['query'],
       ),
-    'getMaxVersion' : IDL.Func([PackageName__1], [Version], ['query']),
-    'getPackageSummary' : IDL.Func(
+    'getHighestVersion' : IDL.Func([PackageName__1], [Version], ['query']),
+    'getPackageDetails' : IDL.Func(
         [PackageName__1, Version],
-        [PackageSummary],
+        [PackageDetails],
         ['query'],
       ),
-    'getReadmeFile' : IDL.Func([PackageName__1, Version], [File], ['query']),
     'getRecentlyUpdatedPackages' : IDL.Func(
         [],
-        [IDL.Vec(PackageSummary)],
+        [IDL.Vec(PackageDetails)],
+        ['query'],
+      ),
+    'getStoragesStats' : IDL.Func(
+        [],
+        [IDL.Vec(IDL.Tuple(StorageId, StorageStats))],
         ['query'],
       ),
     'notifyInstall' : IDL.Func([PackageName__1, Version], [], ['oneway']),
-    'search' : IDL.Func([Text], [IDL.Vec(PackageSummary)], ['query']),
+    'search' : IDL.Func([Text], [IDL.Vec(PackageDetails)], ['query']),
+    'startFileUpload' : IDL.Func(
+        [PublishingId, Text, IDL.Nat, IDL.Vec(IDL.Nat8)],
+        [Result_2],
+        [],
+      ),
     'startPublish' : IDL.Func([PackageConfig], [Result_1], []),
-    'uploadFile' : IDL.Func(
-        [PublishingId, Text, IDL.Vec(IDL.Nat8)],
+    'uploadFileChunk' : IDL.Func(
+        [PublishingId, FileId, IDL.Nat, IDL.Vec(IDL.Nat8)],
         [Result],
         [],
       ),

package/declarations/storage/index.js

@@ -0,0 +1,38 @@
+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=>{
+      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,
+  });
+};
+  
+/**
+ * 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/declarations/storage/storage.did

@@ -0,0 +1,46 @@
+type StorageStats =
+ record {
+   cyclesBalance: nat;
+   fileCount: nat;
+   memorySize: nat;
+ };
+type Storage =
+ service {
+   acceptCycles: () -> ();
+   deleteFile: (FileId) -> ();
+   downloadChunk: (FileId, nat) -> (Result_2) query;
+   finishUpload: (FileId) -> ();
+   getFileIdsRange: (nat, nat) -> (vec FileId) query;
+   getFileMeta: (FileId) -> (Result_1) query;
+   getStats: () -> (StorageStats) query;
+   startUpload: (FileMeta) -> (Result);
+   updateFileOwners: (FileId, vec principal) -> ();
+   uploadChunk: (FileId, nat, Chunk) -> ();
+ };
+type Result_2 =
+ variant {
+   err: Err;
+   ok: Chunk;
+ };
+type Result_1 =
+ variant {
+   err: Err;
+   ok: FileMeta;
+ };
+type Result =
+ variant {
+   err: Err;
+   ok;
+ };
+type FileMeta =
+ record {
+   chunkCount: nat;
+   id: FileId__1;
+   owners: vec principal;
+   path: text;
+ };
+type FileId__1 = text;
+type FileId = text;
+type Err = text;
+type Chunk = blob;
+service : () -> Storage

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

@@ -0,0 +1,37 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+
+export type Chunk = Array<number>;
+export type Err = string;
+export type FileId = string;
+export type FileId__1 = string;
+export interface FileMeta {
+  'id' : FileId__1,
+  'owners' : Array<Principal>,
+  'path' : string,
+  'chunkCount' : bigint,
+}
+export type Result = { 'ok' : null } |
+  { 'err' : Err };
+export type Result_1 = { 'ok' : FileMeta } |
+  { 'err' : Err };
+export type Result_2 = { 'ok' : Chunk } |
+  { 'err' : Err };
+export interface Storage {
+  'acceptCycles' : ActorMethod<[], undefined>,
+  'deleteFile' : ActorMethod<[FileId], undefined>,
+  'downloadChunk' : ActorMethod<[FileId, bigint], Result_2>,
+  'finishUpload' : ActorMethod<[FileId], undefined>,
+  'getFileIdsRange' : ActorMethod<[bigint, bigint], Array<FileId>>,
+  'getFileMeta' : ActorMethod<[FileId], Result_1>,
+  'getStats' : ActorMethod<[], StorageStats>,
+  'startUpload' : ActorMethod<[FileMeta], Result>,
+  'updateFileOwners' : ActorMethod<[FileId, Array<Principal>], undefined>,
+  'uploadChunk' : ActorMethod<[FileId, bigint, Chunk], undefined>,
+}
+export interface StorageStats {
+  'fileCount' : bigint,
+  'cyclesBalance' : bigint,
+  'memorySize' : bigint,
+}
+export interface _SERVICE extends Storage {}

package/declarations/storage/storage.did.js

@@ -0,0 +1,38 @@
+export const idlFactory = ({ IDL }) => {
+  const FileId = IDL.Text;
+  const Chunk = IDL.Vec(IDL.Nat8);
+  const Err = IDL.Text;
+  const Result_2 = IDL.Variant({ 'ok' : Chunk, 'err' : Err });
+  const FileId__1 = IDL.Text;
+  const FileMeta = IDL.Record({
+    'id' : FileId__1,
+    'owners' : IDL.Vec(IDL.Principal),
+    'path' : IDL.Text,
+    'chunkCount' : IDL.Nat,
+  });
+  const Result_1 = IDL.Variant({ 'ok' : FileMeta, 'err' : Err });
+  const StorageStats = IDL.Record({
+    'fileCount' : IDL.Nat,
+    'cyclesBalance' : IDL.Nat,
+    'memorySize' : IDL.Nat,
+  });
+  const Result = IDL.Variant({ 'ok' : IDL.Null, 'err' : Err });
+  const Storage = IDL.Service({
+    'acceptCycles' : IDL.Func([], [], []),
+    'deleteFile' : IDL.Func([FileId], [], []),
+    'downloadChunk' : IDL.Func([FileId, IDL.Nat], [Result_2], ['query']),
+    'finishUpload' : IDL.Func([FileId], [], []),
+    'getFileIdsRange' : IDL.Func(
+        [IDL.Nat, IDL.Nat],
+        [IDL.Vec(FileId)],
+        ['query'],
+      ),
+    'getFileMeta' : IDL.Func([FileId], [Result_1], ['query']),
+    'getStats' : IDL.Func([], [StorageStats], ['query']),
+    'startUpload' : IDL.Func([FileMeta], [Result], []),
+    'updateFileOwners' : IDL.Func([FileId, IDL.Vec(IDL.Principal)], [], []),
+    'uploadChunk' : IDL.Func([FileId, IDL.Nat, Chunk], [], []),
+  });
+  return Storage;
+};
+export const init = ({ IDL }) => { return []; };

package/mops.js

@@ -6,6 +6,7 @@ import path from 'path';
 import fs from 'fs';
 
 import {idlFactory} from './declarations/main/main.did.js';
+import {idlFactory as storageIdlFactory} from './declarations/storage/storage.did.js';
 import {decodeFile} from './pem.js';
 
 
@@ -16,6 +17,8 @@ let apiVersion = '0.1';
 
 let networkFile = new URL('./network.txt', import.meta.url);
 
+export let globalCacheDir = path.resolve(process.env.HOME || process.env.APPDATA, 'mops');
+
 export function setNetwork(network) {
 	fs.writeFileSync(networkFile, network);
 }
@@ -44,7 +47,7 @@ export function getNetwork() {
 }
 
 export let getIdentity = () => {
-	let identityPem = new URL('./identity.pem', import.meta.url);
+	let identityPem = path.resolve(globalCacheDir, 'identity.pem');
 	if (fs.existsSync(identityPem)) {
 		return decodeFile(identityPem);
 	}
@@ -68,6 +71,23 @@ export let mainActor = async () => {
 	});
 };
 
+export let storageActor = async (storageId) => {
+	let network = getNetwork().network;
+	let host = getNetwork().host;
+
+	let identity = getIdentity();
+	let agent = new HttpAgent({host, identity});
+
+	if (network === 'local') {
+		await agent.fetchRootKey();
+	}
+
+	return Actor.createActor(storageIdlFactory, {
+		agent,
+		canisterId: storageId,
+	});
+};
+
 export function checkConfigFile() {
 	let configFile = path.join(process.cwd(), 'mops.toml');
 	if (!fs.existsSync(configFile)) {
@@ -82,9 +102,9 @@ export function progressBar(step, total) {
 	return `[${':'.repeat(done)}${' '.repeat(10 - done)}]`;
 }
 
-export async function getMaxVersion(pkgName) {
+export async function getHighestVersion(pkgName) {
 	let actor = await mainActor();
-	return actor.getMaxVersion(pkgName);
+	return actor.getHighestVersion(pkgName);
 }
 
 export function readConfig(configFile = path.join(process.cwd(), 'mops.toml')) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ic-mops",
-	"version": "0.1.4",
+	"version": "0.1.7",
 	"type": "module",
 	"bin": {
 		"mops": "cli.js"