ic-mops 0.1.3 → 0.1.6

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 {getLastVersion, 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';
@@ -55,17 +55,22 @@ program
 			config.dependencies = {};
 		}
 
+		let compatible = await checkApiCompatibility();
+		if (!compatible) {
+			return;
+		}
+
 		if (!pkg) {
 			installAll(options);
 		}
 		else {
-			let version = await getLastVersion(pkg);
-			await install(pkg, version, options.verbose);
+			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}"`);
 		}
 	});
 
@@ -74,7 +79,10 @@ program
 	.command('publish')
 	.description('Publish package to the mops registry')
 	.action(async () => {
-		await publish();
+		let compatible = await checkApiCompatibility();
+		if (compatible) {
+			await publish();
+		}
 	});
 
 // set-network

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-all.js

@@ -12,7 +12,7 @@ export async function installAll({verbose} = {}) {
 	let deps = Object.entries(config.dependencies || {});
 
 	for (let [pkg, ver] of deps) {
-		await install(pkg, ver, verbose);
+		await install(pkg, ver, {verbose});
 	}
 
 	logUpdate.clear();

package/commands/install.js

@@ -1,16 +1,17 @@
 import path from 'path';
 import fs from 'fs';
 import logUpdate from 'log-update';
-import {checkConfigFile, getLastVersion, 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 = false, dep = false) {
+export async function install(pkg, version = '', {verbose, silent, dep} = {}) {
 	if (!checkConfigFile()) {
 		return;
 	}
 
 	if (!version) {
-		version = await getLastVersion(pkg);
+		version = await getHighestVersion(pkg);
 	}
 
 	let dir = path.join(process.cwd(), '.mops', `${pkg}@${version}`);
@@ -18,44 +19,60 @@ export async function install(pkg, version = '', verbose = false, dep = false) {
 
 	// cache
 	if (fs.existsSync(dir)) {
-		logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (cache)`);
+		silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} (cache)`);
 	}
 	// no cache
 	else {
 		fs.mkdirSync(dir, {recursive: true});
 
+		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;
 		let step = 0;
 		let progress = () => {
 			step++;
-			logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} ${progressBar(step, total)}`);
+			silent || logUpdate(`${dep ? 'Dependency' : 'Installing'} ${pkg}@${version} ${progressBar(step, total)}`);
 		};
 
 		// 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();
 		});
-
-		// TODO: slow (update call)
-		// if (!dep) {
-		// 	await actor.notifyInstall(pkg, version);
-		// }
 	}
 
 	if (verbose) {
-		logUpdate.done();
+		silent || logUpdate.done();
 	}
 
 	// install dependencies
 	let config = readConfig(path.join(dir, 'mops.toml'));
 	for (let [name, version] of Object.entries(config.dependencies || {})) {
-		await install(name, version, verbose, true);
+		await install(name, version, {verbose, silent, dep: true});
 	}
 }

package/commands/publish.js

@@ -17,7 +17,7 @@ export async function publish() {
 
 	// validate
 	for (let key of Object.keys(config)) {
-		if (!['package', 'dependencies', 'permissions', 'scripts'].includes(key)) {
+		if (!['package', 'dependencies', 'scripts'].includes(key)) {
 			console.log(chalk.red('Error: ') + `Unknown config section [${key}]`);
 			return;
 		}
@@ -59,7 +59,6 @@ export async function publish() {
 		'homepage',
 		'readme',
 		'license',
-		'isPrivate',
 		'files',
 		'dfx',
 		'moc',
@@ -101,11 +100,6 @@ export async function publish() {
 		return;
 	}
 
-	if (config.package.permissions && Object.keys(config.package.permissions).length > 50) {
-		console.log(chalk.red('Error: ') + 'max permissions is 50');
-		return;
-	}
-
 	if (config.package.keywords) {
 		for (let keyword of config.package.keywords) {
 			if (keyword.length > 20) {
@@ -135,7 +129,6 @@ export async function publish() {
 		documentation: config.package.documentation || '',
 		readme: 'README.md',
 		license: config.package.license || '',
-		isPrivate: false,
 		owner: getIdentity()?.getPrincipal() || Principal.anonymous(),
 		dfx: config.package.dfx || '',
 		moc: config.package.moc || '',
@@ -143,7 +136,6 @@ export async function publish() {
 		dependencies: (Object.entries(config.dependencies || {})).map(([name, version]) => {
 			return {name, version};
 		}),
-		permissions: [],
 		scripts: [],
 	};
 
@@ -196,8 +188,27 @@ 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, start = i * chunkSize; start < content.length; i++) {
+			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 {getLastVersion, readConfig} from '../mops.js';
+import {getHighestVersion, readConfig} from '../mops.js';
 
 function rootDir(cwd = process.cwd()) {
 	let configFile = path.join(cwd, 'mops.toml');
@@ -73,8 +73,8 @@ export async function sources({verbose} = {}) {
 			packages['base-unofficial'] = downloadedPackages['base-unofficial'];
 		}
 		else {
-			let version = await getLastVersion('base-unofficial');
-			await install('base-unofficial', version, false, true);
+			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,23 +30,39 @@ type Result =
  };
 type PublishingId = text;
 type PublishingErr = text;
-type Permission = 
+type PackagePublication = 
  record {
-   access: Access;
+   storage: principal;
+   time: Time;
    user: principal;
  };
-type PackageSummary = 
+type PackageName__1 = text;
+type PackageName = text;
+type PackageDetails = 
  record {
-   description: text;
+   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;
+   homepage: text;
    keywords: vec text;
+   license: text;
+   moc: text;
    name: PackageName;
-   updatedAt: Time;
+   readme: text;
+   repository: text;
+   scripts: vec Script;
    version: text;
  };
-type PackageName__1 = text;
-type PackageName = text;
 type PackageConfig = 
  record {
    dependencies: vec Dependency;
@@ -43,48 +71,36 @@ type PackageConfig =
    documentation: text;
    donation: text;
    homepage: text;
-   isPrivate: bool;
    keywords: vec text;
    license: text;
    moc: text;
    name: PackageName;
-   owner: principal;
-   permissions: vec Permission;
    readme: text;
    repository: text;
    scripts: vec Script;
    version: text;
  };
 type FileId = text;
-type File = 
- record {
-   content: blob;
-   id: FileId;
-   path: Text;
- };
 type Err = text;
 type Dependency = 
  record {
    name: PackageName;
    version: text;
  };
-type Access = 
- variant {
-   readOnly;
-   readWrite;
- };
 service : {
   finishPublish: (PublishingId) -> (Result);
-  getConfig: (PackageName__1, Version) -> (PackageConfig) query;
-  getFile: (FileId) -> (File) query;
+  getApiVersion: () -> (Text) query;
   getFileIds: (PackageName__1, Version) -> (vec FileId) query;
-  getLastConfig: (PackageName__1) -> (PackageConfig) query;
-  getLastVersion: (PackageName__1) -> (Version) 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);
-  whoami: () -> (Text) query;
+  uploadFileChunk: (PublishingId, FileId, nat, blob) -> (Result);
 }

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

@@ -1,22 +1,13 @@
 import type { Principal } from '@dfinity/principal';
 import type { ActorMethod } from '@dfinity/agent';
 
-export type Access = { 'readOnly' : null } |
-  { 'readWrite' : null };
 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,
   'moc' : string,
-  'permissions' : Array<Permission>,
   'scripts' : Array<Script>,
-  'owner' : Principal,
   'documentation' : string,
   'name' : PackageName,
   'homepage' : string,
@@ -24,46 +15,76 @@ export interface PackageConfig {
   'version' : string,
   'keywords' : Array<string>,
   'donation' : string,
-  'isPrivate' : boolean,
   'repository' : string,
   'dependencies' : Array<Dependency>,
   '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>,
+  'documentation' : string,
   'name' : PackageName,
-  'downloadsTotal' : bigint,
-  'downloadsInLast30Days' : bigint,
+  'homepage' : string,
   'description' : string,
   'version' : string,
   'keywords' : Array<string>,
-  'updatedAt' : Time,
+  'donation' : string,
+  '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 interface Permission { 'access' : Access, '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>,
-  'getConfig' : ActorMethod<[PackageName__1, Version], PackageConfig>,
-  'getFile' : ActorMethod<[FileId], File>,
+  'getApiVersion' : ActorMethod<[], Text>,
   'getFileIds' : ActorMethod<[PackageName__1, Version], Array<FileId>>,
-  'getLastConfig' : ActorMethod<[PackageName__1], PackageConfig>,
-  'getLastVersion' : ActorMethod<[PackageName__1], Version>,
-  '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>,
-  'whoami' : ActorMethod<[], Text>,
+  'uploadFileChunk' : ActorMethod<
+    [PublishingId, FileId, bigint, Array<number>],
+    Result,
+  >,
 }

package/declarations/main/main.did.js

@@ -2,19 +2,17 @@ export const idlFactory = ({ IDL }) => {
   const PublishingId = IDL.Text;
   const Err = IDL.Text;
   const Result = IDL.Variant({ 'ok' : IDL.Null, 'err' : Err });
+  const Text = IDL.Text;
   const PackageName__1 = IDL.Text;
   const Version = IDL.Text;
-  const Access = IDL.Variant({ 'readOnly' : IDL.Null, 'readWrite' : IDL.Null });
-  const Permission = IDL.Record({ 'access' : Access, 'user' : IDL.Principal });
+  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,
-    'permissions' : IDL.Vec(Permission),
     'scripts' : IDL.Vec(Script),
-    'owner' : IDL.Principal,
     'documentation' : IDL.Text,
     'name' : PackageName,
     'homepage' : IDL.Text,
@@ -22,61 +20,86 @@ export const idlFactory = ({ IDL }) => {
     'version' : IDL.Text,
     'keywords' : IDL.Vec(IDL.Text),
     'donation' : IDL.Text,
-    'isPrivate' : IDL.Bool,
     'repository' : IDL.Text,
     'dependencies' : IDL.Vec(Dependency),
     'license' : IDL.Text,
     'readme' : IDL.Text,
   });
-  const FileId = IDL.Text;
-  const Text = IDL.Text;
-  const File = IDL.Record({
-    'id' : FileId,
-    'content' : IDL.Vec(IDL.Nat8),
-    'path' : Text,
-  });
   const Time = IDL.Int;
-  const PackageSummary = IDL.Record({
-    'name' : PackageName,
+  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),
+    'documentation' : IDL.Text,
+    'name' : PackageName,
+    'homepage' : IDL.Text,
     'description' : IDL.Text,
     'version' : IDL.Text,
     'keywords' : IDL.Vec(IDL.Text),
-    'updatedAt' : Time,
+    'donation' : IDL.Text,
+    'repository' : IDL.Text,
+    'dependencies' : IDL.Vec(Dependency),
+    'license' : IDL.Text,
+    'readme' : IDL.Text,
   });
   const PublishingErr = IDL.Text;
   const Result_1 = IDL.Variant({ 'ok' : PublishingId, 'err' : PublishingErr });
   return IDL.Service({
     'finishPublish' : IDL.Func([PublishingId], [Result], []),
-    'getConfig' : IDL.Func(
+    'getApiVersion' : IDL.Func([], [Text], ['query']),
+    'getFileIds' : IDL.Func(
         [PackageName__1, Version],
-        [PackageConfig],
+        [IDL.Vec(FileId)],
         ['query'],
       ),
-    'getFile' : IDL.Func([FileId], [File], ['query']),
-    'getFileIds' : IDL.Func(
+    'getHighestVersion' : IDL.Func([PackageName__1], [Version], ['query']),
+    'getPackageDetails' : IDL.Func(
         [PackageName__1, Version],
-        [IDL.Vec(FileId)],
+        [PackageDetails],
         ['query'],
       ),
-    'getLastConfig' : IDL.Func([PackageName__1], [PackageConfig], ['query']),
-    'getLastVersion' : IDL.Func([PackageName__1], [Version], ['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],
         [],
       ),
-    'whoami' : IDL.Func([], [Text], ['query']),
   });
 };
 export const init = ({ IDL }) => { return []; };

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,13 +6,19 @@ 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';
 
 
 global.fetch = fetch;
 
+// (!) make changes in pair with backend
+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);
 }
@@ -41,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);
 	}
@@ -65,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)) {
@@ -79,12 +102,31 @@ export function progressBar(step, total) {
 	return `[${':'.repeat(done)}${' '.repeat(10 - done)}]`;
 }
 
-export async function getLastVersion(pkgName) {
+export async function getHighestVersion(pkgName) {
 	let actor = await mainActor();
-	return actor.getLastVersion(pkgName);
+	return actor.getHighestVersion(pkgName);
 }
 
 export function readConfig(configFile = path.join(process.cwd(), 'mops.toml')) {
 	let text = fs.readFileSync(configFile).toString();
 	return TOML.parse(text);
+}
+
+// warn on minor mismatch
+// err on major mismatch
+export async function checkApiCompatibility() {
+	let actor = await mainActor();
+	let backendApiVer = await actor.getApiVersion();
+	if (backendApiVer.split('.')[0] !== apiVersion.split('.')[0]) {
+		console.log(chalk.red('ERR: ') + `CLI incompatible with backend. CLI v${apiVersion}, Backend v${backendApiVer}`);
+		console.log('Run ' + chalk.greenBright('npm i -g ic-mops') + ' to upgrade cli.');
+		return false;
+	}
+	else if (backendApiVer.split('.')[1] !== apiVersion.split('.')[1]) {
+		console.log('-'.repeat(50));
+		console.log(chalk.yellow('WARN: ') + `CLI probably incompatible with backend. CLI v${apiVersion}, Backend v${backendApiVer}`);
+		console.log('Recommended to run ' + chalk.greenBright('npm i -g ic-mops') + ' to upgrade cli.');
+		console.log('-'.repeat(50));
+	}
+	return true;
 }

package/package.json

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