ic-mops 1.1.2 → 1.3.0-pre.0

package/dist/cli.js

@@ -20,11 +20,12 @@ import { sync } from './commands/sync.js';
 import { outdated } from './commands/outdated.js';
 import { update } from './commands/update.js';
 import { bench } from './commands/bench.js';
-import { transferOwnership } from './commands/transfer-ownership.js';
 import { toolchain } from './commands/toolchain/index.js';
 import * as self from './commands/self.js';
 import { resolvePackages } from './resolve-packages.js';
 import { watch } from './commands/watch/watch.js';
+import { addOwner, printOwners, removeOwner } from './commands/owner.js';
+import { addMaintainer, printMaintainers, removeMaintainer } from './commands/maintainer.js';
 events.setMaxListeners(20);
 let networkFile = getNetworkFile();
 if (fs.existsSync(networkFile)) {
@@ -183,6 +184,7 @@ program
     .addOption(new Option('--mode <mode>', 'Test mode').choices(['interpreter', 'wasi', 'replica']).default('interpreter'))
     .addOption(new Option('--replica <replica>', 'Which replica to use to run tests in replica mode').choices(['dfx', 'pocket-ic']))
     .option('-w, --watch', 'Enable watch mode')
+    .option('--verbose', 'Verbose output')
     .action(async (filter, options) => {
     checkConfigFile(true);
     await installAll({ silent: true, lock: 'ignore', installFromLockFile: true });
@@ -249,6 +251,58 @@ userCommand
     await getUserProp(prop);
 });
 program.addCommand(userCommand);
+// mops owner *
+const ownerCommand = new Command('owner').description('Package owner management');
+// mops owner list
+ownerCommand
+    .command('list')
+    .description('List package owners')
+    .action(async () => {
+    await printOwners();
+});
+// mops owner add
+ownerCommand
+    .command('add <principal>')
+    .description('Add package owner')
+    .addOption(new Option('--yes', 'Do not ask for confirmation'))
+    .action(async (data, options) => {
+    await addOwner(data, options.yes);
+});
+// mops owner remove
+ownerCommand
+    .command('remove <principal>')
+    .description('Remove package owner')
+    .addOption(new Option('--yes', 'Do not ask for confirmation'))
+    .action(async (data, options) => {
+    await removeOwner(data, options.yes);
+});
+program.addCommand(ownerCommand);
+// mops maintainer *
+const maintainerCommand = new Command('maintainer').description('Package maintainer management');
+// mops maintainer list
+maintainerCommand
+    .command('list')
+    .description('List package maintainers')
+    .action(async () => {
+    await printMaintainers();
+});
+// mops maintainer add
+maintainerCommand
+    .command('add <principal>')
+    .description('Add package maintainer')
+    .addOption(new Option('--yes', 'Do not ask for confirmation'))
+    .action(async (data, options) => {
+    await addMaintainer(data, options.yes);
+});
+// mops maintainer remove
+maintainerCommand
+    .command('remove <principal>')
+    .description('Remove package maintainer')
+    .addOption(new Option('--yes', 'Do not ask for confirmation'))
+    .action(async (data, options) => {
+    await removeMaintainer(data, options.yes);
+});
+program.addCommand(maintainerCommand);
 // bump
 program
     .command('bump [major|minor|patch]')
@@ -279,13 +333,6 @@ program
     .action(async (pkg, options) => {
     await update(pkg, options);
 });
-// transfer-ownership
-program
-    .command('transfer-ownership [to-principal]')
-    .description('Transfer ownership of the current package to another principal')
-    .action(async (toPrincipal) => {
-    await transferOwnership(toPrincipal);
-});
 // toolchain
 const toolchainCommand = new Command('toolchain').description('Toolchain management');
 toolchainCommand

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

@@ -1,5 +1,6 @@
 import process from 'node:process';
 import path from 'node:path';
+import { existsSync } from 'node:fs';
 import { createLogUpdate } from 'log-update';
 import { getRootDir, readConfig } from '../../mops.js';
 import { installDeps } from './install-deps.js';
@@ -19,7 +20,11 @@ export async function installLocalDep(pkg, pkgPath = '', { verbose, silent, igno
     // install dependencies
     if (!ignoreTransitive) {
         let dir = path.resolve(getRootDir(), pkgPath).replaceAll('{MOPS_ENV}', process.env.MOPS_ENV || 'local');
-        let config = readConfig(path.join(dir, 'mops.toml'));
+        let mopsToml = path.join(dir, 'mops.toml');
+        if (!existsSync(mopsToml)) {
+            return true;
+        }
+        let config = readConfig(mopsToml);
         return installDeps(Object.values(config.dependencies || {}), { silent, verbose }, pkgPath);
     }
     else {

package/dist/commands/maintainer.d.ts

@@ -0,0 +1,3 @@
+export declare function printMaintainers(): Promise<void>;
+export declare function addMaintainer(maintainer: string, yes?: boolean): Promise<void>;
+export declare function removeMaintainer(maintainer: string, yes?: boolean): Promise<void>;

package/dist/commands/maintainer.js

@@ -0,0 +1,88 @@
+import process from 'node:process';
+import chalk from 'chalk';
+import { checkConfigFile, getIdentity, readConfig } from '../mops.js';
+import { mainActor } from '../api/actors.js';
+import { Principal } from '@dfinity/principal';
+import prompts from 'prompts';
+export async function printMaintainers() {
+    if (!checkConfigFile()) {
+        return;
+    }
+    let config = readConfig();
+    let actor = await mainActor();
+    let maintainers = await actor.getPackageMaintainers(config.package?.name || '');
+    console.log(`Maintainers of package ${chalk.bold(config.package?.name)}:`);
+    for (let maintainer of maintainers) {
+        console.log(maintainer.toText());
+    }
+}
+export async function addMaintainer(maintainer, yes = false) {
+    if (!checkConfigFile()) {
+        return;
+    }
+    let config = readConfig();
+    let principal = Principal.fromText(maintainer);
+    if (!yes) {
+        let promptsConfig = {
+            onCancel() {
+                console.log('aborted');
+                process.exit(0);
+            },
+        };
+        let { confirm } = await prompts({
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to add maintainer ${chalk.yellow(maintainer)} to ${chalk.yellow(config.package?.name)} package?`,
+            initial: true,
+        }, promptsConfig);
+        if (!confirm) {
+            return;
+        }
+    }
+    let identity = await getIdentity();
+    let actor = await mainActor(identity);
+    let res = await actor.addMaintainer(config.package?.name || '', principal);
+    if ('ok' in res) {
+        console.log(chalk.green('Success!'));
+        console.log(`Added maintainer ${chalk.bold(maintainer)} to package ${chalk.bold(config.package?.name)}`);
+    }
+    else {
+        console.error(chalk.red('Error: ') + res.err);
+        process.exit(1);
+    }
+}
+export async function removeMaintainer(maintainer, yes = false) {
+    if (!checkConfigFile()) {
+        return;
+    }
+    let config = readConfig();
+    let principal = Principal.fromText(maintainer);
+    if (!yes) {
+        let promptsConfig = {
+            onCancel() {
+                console.log('aborted');
+                process.exit(0);
+            },
+        };
+        let { confirm } = await prompts({
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to remove maintainer ${chalk.red(maintainer)} from ${chalk.red(config.package?.name)} package?`,
+            initial: true,
+        }, promptsConfig);
+        if (!confirm) {
+            return;
+        }
+    }
+    let identity = await getIdentity();
+    let actor = await mainActor(identity);
+    let res = await actor.removeMaintainer(config.package?.name || '', principal);
+    if ('ok' in res) {
+        console.log(chalk.green('Success!'));
+        console.log(`Removed maintainer ${chalk.bold(maintainer)} from package ${chalk.bold(config.package?.name)}`);
+    }
+    else {
+        console.error(chalk.red('Error: ') + res.err);
+        process.exit(1);
+    }
+}

package/dist/commands/owner.d.ts

@@ -0,0 +1,3 @@
+export declare function printOwners(): Promise<void>;
+export declare function addOwner(owner: string, yes?: boolean): Promise<void>;
+export declare function removeOwner(owner: string, yes?: boolean): Promise<void>;

package/dist/commands/owner.js

@@ -0,0 +1,88 @@
+import process from 'node:process';
+import chalk from 'chalk';
+import { checkConfigFile, getIdentity, readConfig } from '../mops.js';
+import { mainActor } from '../api/actors.js';
+import { Principal } from '@dfinity/principal';
+import prompts from 'prompts';
+export async function printOwners() {
+    if (!checkConfigFile()) {
+        return;
+    }
+    let config = readConfig();
+    let actor = await mainActor();
+    let owners = await actor.getPackageOwners(config.package?.name || '');
+    console.log(`Owners of package ${chalk.bold(config.package?.name)}:`);
+    for (let owner of owners) {
+        console.log(owner.toText());
+    }
+}
+export async function addOwner(owner, yes = false) {
+    if (!checkConfigFile()) {
+        return;
+    }
+    let config = readConfig();
+    let principal = Principal.fromText(owner);
+    if (!yes) {
+        let promptsConfig = {
+            onCancel() {
+                console.log('aborted');
+                process.exit(0);
+            },
+        };
+        let { confirm } = await prompts({
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to add owner ${chalk.yellow(owner)} to ${chalk.yellow(config.package?.name)} package?`,
+            initial: true,
+        }, promptsConfig);
+        if (!confirm) {
+            return;
+        }
+    }
+    let identity = await getIdentity();
+    let actor = await mainActor(identity);
+    let res = await actor.addOwner(config.package?.name || '', principal);
+    if ('ok' in res) {
+        console.log(chalk.green('Success!'));
+        console.log(`Added owner ${chalk.bold(owner)} to package ${chalk.bold(config.package?.name)}`);
+    }
+    else {
+        console.error(chalk.red('Error: ') + res.err);
+        process.exit(1);
+    }
+}
+export async function removeOwner(owner, yes = false) {
+    if (!checkConfigFile()) {
+        return;
+    }
+    let config = readConfig();
+    let principal = Principal.fromText(owner);
+    if (!yes) {
+        let promptsConfig = {
+            onCancel() {
+                console.log('aborted');
+                process.exit(0);
+            },
+        };
+        let { confirm } = await prompts({
+            type: 'confirm',
+            name: 'confirm',
+            message: `Are you sure you want to remove owner ${chalk.red(owner)} from ${chalk.red(config.package?.name)} package?`,
+            initial: true,
+        }, promptsConfig);
+        if (!confirm) {
+            return;
+        }
+    }
+    let identity = await getIdentity();
+    let actor = await mainActor(identity);
+    let res = await actor.removeOwner(config.package?.name || '', principal);
+    if ('ok' in res) {
+        console.log(chalk.green('Success!'));
+        console.log(`Removed owner ${chalk.bold(owner)} from package ${chalk.bold(config.package?.name)}`);
+    }
+    else {
+        console.error(chalk.red('Error: ') + res.err);
+        process.exit(1);
+    }
+}

package/dist/commands/replica.d.ts

@@ -3,13 +3,13 @@ import { PassThrough } from 'node:stream';
 import { IDL } from '@dfinity/candid';
 import { PocketIc, PocketIcServer } from 'pic-ic';
 type StartOptions = {
-    type?: 'dfx' | 'pocket-ic';
+    type?: 'dfx' | 'pocket-ic' | 'dfx-pocket-ic';
     dir?: string;
     verbose?: boolean;
     silent?: boolean;
 };
 export declare class Replica {
-    type: 'dfx' | 'pocket-ic';
+    type: 'dfx' | 'pocket-ic' | 'dfx-pocket-ic';
     verbose: boolean;
     canisters: Record<string, {
         cwd: string;
@@ -43,6 +43,7 @@ export declare class Replica {
     dfxJson(canisterName: string, wasmPath?: string, didPath?: string): {
         version: number;
         canisters: Record<string, any>;
+        dfx: string;
         defaults: {
             build: {
                 packtool: string;

package/dist/commands/replica.js

@@ -6,8 +6,10 @@ import { PassThrough } from 'node:stream';
 import { spawn as spawnAsync } from 'promisify-child-process';
 import { Actor, HttpAgent } from '@dfinity/agent';
 import { PocketIc, PocketIcServer } from 'pic-ic';
+import chalk from 'chalk';
 import { readConfig } from '../mops.js';
 import { toolchain } from './toolchain/index.js';
+import { getDfxVersion } from '../helpers/get-dfx-version.js';
 export class Replica {
     constructor() {
         this.type = 'dfx';
@@ -21,16 +23,28 @@ export class Replica {
         this.verbose = verbose ?? this.verbose;
         this.dir = dir ?? this.dir;
         silent || console.log(`Starting ${this.type} replica...`);
-        if (this.type == 'dfx') {
+        if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
             fs.mkdirSync(this.dir, { recursive: true });
             fs.writeFileSync(path.join(this.dir, 'dfx.json'), JSON.stringify(this.dfxJson(''), null, 2));
             fs.writeFileSync(path.join(this.dir, 'canister.did'), 'service : { runTests: () -> (); }');
             await this.stop();
-            this.dfxProcess = spawn('dfx', ['start', '--clean', '--artificial-delay', '0', (this.verbose ? '' : '-qqqq')].filter(x => x), { cwd: this.dir });
+            this.dfxProcess = spawn('dfx', ['start', this.type === 'dfx-pocket-ic' ? '--pocketic' : '', '--clean', (this.verbose ? '' : '-qqqq'), '--artificial-delay', '0'].filter(x => x).flat(), { cwd: this.dir });
             // process canister logs
             this._attachCanisterLogHandler(this.dfxProcess);
             this.dfxProcess.stdout.on('data', (data) => {
-                console.log('DFX:', data.toString());
+                if (this.verbose) {
+                    console.log('DFX:', data.toString());
+                }
+            });
+            this.dfxProcess.stderr.on('data', (data) => {
+                if (this.verbose) {
+                    console.error('DFX:', data.toString());
+                }
+                if (data.toString().includes('Failed to bind socket to')) {
+                    console.error(chalk.red(data.toString()));
+                    console.log('Please try again after some time');
+                    process.exit(11);
+                }
             });
             // await for dfx to start
             let ok = false;
@@ -87,9 +101,21 @@ export class Replica {
         });
     }
     async stop(sigint = false) {
-        if (this.type == 'dfx') {
-            this.dfxProcess?.kill();
-            // execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), {cwd: this.dir, timeout: 10_000, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe']});
+        if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
+            if (this.dfxProcess) {
+                this.dfxProcess.kill();
+                // give replica some time to stop
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 1000);
+                });
+            }
+            // if (!this.dfxProcess) {
+            // 	try {
+            // 		execSync('dfx killall', {cwd: this.dir, timeout: 3_000, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe']});
+            //			execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), {cwd: this.dir, timeout: 10_000, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe']});
+            // 	}
+            // 	catch {}
+            // }
         }
         else if (this.pocketIc && this.pocketIcServer) {
             if (!sigint) {
@@ -99,7 +125,7 @@ export class Replica {
         }
     }
     async deploy(name, wasm, idlFactory, cwd = process.cwd(), signal) {
-        if (this.type === 'dfx') {
+        if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
             // prepare dfx.json for current canister
             let dfxJson = path.join(this.dir, 'dfx.json');
             let oldDfxJsonData;
@@ -202,6 +228,7 @@ export class Replica {
         return {
             version: 1,
             canisters,
+            dfx: getDfxVersion(),
             defaults: {
                 build: {
                     packtool: 'mops sources',

package/dist/commands/test/test.d.ts

@@ -1,12 +1,13 @@
 import { Reporter } from './reporters/reporter.js';
 import { TestMode } from '../../types.js';
 type ReporterName = 'verbose' | 'files' | 'compact' | 'silent';
-type ReplicaName = 'dfx' | 'pocket-ic';
+type ReplicaName = 'dfx' | 'pocket-ic' | 'dfx-pocket-ic';
 type TestOptions = {
     watch: boolean;
     reporter: ReporterName;
     mode: TestMode;
     replica: ReplicaName;
+    verbose: boolean;
 };
 export declare function test(filter?: string, options?: Partial<TestOptions>): Promise<void>;
 export declare function testWithReporter(reporterName: ReporterName | Reporter | undefined, filter: string | undefined, defaultMode: TestMode | undefined, replicaType: ReplicaName, watch?: boolean, signal?: AbortSignal): Promise<boolean>;

package/dist/commands/test/test.js

@@ -7,6 +7,7 @@ import chalk from 'chalk';
 import { globSync } from 'glob';
 import chokidar from 'chokidar';
 import debounce from 'debounce';
+import { SemVer } from 'semver';
 import { sources } from '../sources.js';
 import { getRootDir, readConfig } from '../../mops.js';
 import { parallel } from '../../parallel.js';
@@ -19,6 +20,7 @@ import { SilentReporter } from './reporters/silent-reporter.js';
 import { toolchain } from '../toolchain/index.js';
 import { Replica } from '../replica.js';
 import { PassThrough } from 'node:stream';
+import { getDfxVersion } from '../../helpers/get-dfx-version.js';
 let ignore = [
     '**/node_modules/**',
     '**/.mops/**',
@@ -43,7 +45,18 @@ export async function test(filter = '', options = {}) {
     let config = readConfig();
     let rootDir = getRootDir();
     let replicaType = options.replica ?? (config.toolchain?.['pocket-ic'] ? 'pocket-ic' : 'dfx');
+    if (replicaType === 'pocket-ic' && !config.toolchain?.['pocket-ic']) {
+        let dfxVersion = getDfxVersion();
+        if (!dfxVersion || new SemVer(dfxVersion).compare('0.24.1') < 0) {
+            console.log(chalk.red('Please update dfx to the version >=0.24.1 or specify pocket-ic version in mops.toml'));
+            process.exit(1);
+        }
+        else {
+            replicaType = 'dfx-pocket-ic';
+        }
+    }
     replica.type = replicaType;
+    replica.verbose = !!options.verbose;
     if (options.watch) {
         replica.ttl = 60 * 15; // 15 minutes
         let sigint = false;
@@ -156,6 +169,7 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
     }
     let testTempDir = path.join(getRootDir(), '.mops/.test/');
     replica.dir = testTempDir;
+    fs.rmSync(testTempDir, { recursive: true, force: true });
     fs.mkdirSync(testTempDir, { recursive: true });
     await parallel(os.cpus().length, files, async (file) => {
         if (signal?.aborted) {

package/dist/commands/watch/parseDfxJson.js

@@ -10,13 +10,13 @@ function readDfxJson() {
 }
 export function getMotokoCanisters() {
     let dfxJson = readDfxJson();
-    return Object.fromEntries(Object.entries(dfxJson.canisters)
+    return Object.fromEntries(Object.entries(dfxJson.canisters || {})
         .filter(([_, canister]) => canister.type === 'motoko')
         .map(([name, canister]) => [name, canister.main ?? '']));
 }
 export function getMotokoCanistersWithDeclarations() {
     let dfxJson = readDfxJson();
-    return Object.fromEntries(Object.entries(dfxJson.canisters)
+    return Object.fromEntries(Object.entries(dfxJson.canisters || {})
         .filter(([_, canister]) => canister.type === 'motoko' && canister.declarations)
         .map(([name, canister]) => [name, canister.main ?? '']));
 }