ic-mops 1.11.1 → 2.0.0

package/dist/commands/replica.d.ts

@@ -1,15 +1,16 @@
-import { ChildProcessWithoutNullStreams } from 'node:child_process';
-import { PassThrough } from 'node:stream';
-import { IDL } from '@dfinity/candid';
-import { PocketIc, PocketIcServer } from 'pic-ic';
+import { ChildProcessWithoutNullStreams } from "node:child_process";
+import { PassThrough } from "node:stream";
+import { IDL } from "@icp-sdk/core/candid";
+import { PocketIc, PocketIcServer } from "pic-ic";
+import { PocketIc as PocketIcMops, PocketIcServer as PocketIcServerMops } from "pic-js-mops";
 type StartOptions = {
-    type?: 'dfx' | 'pocket-ic' | 'dfx-pocket-ic';
+    type?: "dfx" | "pocket-ic" | "dfx-pocket-ic";
     dir?: string;
     verbose?: boolean;
     silent?: boolean;
 };
 export declare class Replica {
-    type: 'dfx' | 'pocket-ic' | 'dfx-pocket-ic';
+    type: "dfx" | "pocket-ic" | "dfx-pocket-ic";
     verbose: boolean;
     canisters: Record<string, {
         cwd: string;
@@ -17,8 +18,8 @@ export declare class Replica {
         actor: any;
         stream: PassThrough;
     }>;
-    pocketIcServer?: PocketIcServer;
-    pocketIc?: PocketIc;
+    pocketIcServer?: PocketIcServer | PocketIcServerMops;
+    pocketIc?: PocketIc | PocketIcMops;
     dfxProcess?: ChildProcessWithoutNullStreams;
     dir: string;
     ttl: number;

package/dist/commands/replica.js

@@ -1,112 +1,135 @@
-import process from 'node:process';
-import { execSync, spawn } from 'node:child_process';
-import path from 'node:path';
-import fs from 'node:fs';
-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';
+import process from "node:process";
+import { execSync, spawn, } from "node:child_process";
+import path from "node:path";
+import fs from "node:fs";
+import { PassThrough } from "node:stream";
+import { spawn as spawnAsync } from "promisify-child-process";
+import { Actor, HttpAgent } from "@icp-sdk/core/agent";
+import { PocketIc, PocketIcServer } from "pic-ic";
+import { PocketIc as PocketIcMops, PocketIcServer as PocketIcServerMops, } from "pic-js-mops";
+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 {
-    type = 'dfx';
+    type = "dfx";
     verbose = false;
     canisters = {};
     pocketIcServer;
     pocketIc;
     dfxProcess;
-    dir = ''; // absolute path (/.../.mops/.test/)
+    dir = ""; // absolute path (/.../.mops/.test/)
     ttl = 60;
     async start({ type, dir, verbose, silent } = {}) {
         this.type = type ?? this.type;
         this.verbose = verbose ?? this.verbose;
         this.dir = dir ?? this.dir;
         silent || console.log(`Starting ${this.type} replica...`);
-        if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
+        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: () -> (); }');
+            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', this.type === 'dfx-pocket-ic' ? '--pocketic' : '', '--clean', (this.verbose ? '' : '-qqqq'), '--artificial-delay', '0'].filter(x => x).flat(), { 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) => {
+            this.dfxProcess.stdout.on("data", (data) => {
                 if (this.verbose) {
-                    console.log('DFX:', data.toString());
+                    console.log("DFX:", data.toString());
                 }
             });
-            this.dfxProcess.stderr.on('data', (data) => {
+            this.dfxProcess.stderr.on("data", (data) => {
                 if (this.verbose) {
-                    console.error('DFX:', data.toString());
+                    console.error("DFX:", data.toString());
                 }
-                if (data.toString().includes('Failed to bind socket to')) {
+                if (data.toString().includes("Failed to bind socket to")) {
                     console.error(chalk.red(data.toString()));
-                    console.log('Please try again after some time');
+                    console.log("Please try again after some time");
                     process.exit(11);
                 }
             });
             // await for dfx to start
             let ok = false;
             while (!ok) {
-                await fetch('http://127.0.0.1:4945/api/v2/status')
-                    .then(res => {
+                await fetch("http://127.0.0.1:4945/api/v2/status")
+                    .then((res) => {
                     if (res.status === 200) {
                         ok = true;
                     }
                 })
                     .catch(() => { })
                     .finally(() => {
-                    return new Promise(resolve => setTimeout(resolve, 1000));
+                    return new Promise((resolve) => setTimeout(resolve, 1000));
                 });
             }
         }
         else {
-            let pocketIcBin = await toolchain.bin('pocket-ic');
-            // eslint-disable-next-line
+            let pocketIcBin = await toolchain.bin("pocket-ic");
             let config = readConfig();
-            if (config.toolchain?.['pocket-ic'] !== '4.0.0') {
-                console.error('Current Mops CLI only supports pocket-ic 4.0.0');
+            if (config.toolchain?.["pocket-ic"] !== "4.0.0" &&
+                !config.toolchain?.["pocket-ic"]?.startsWith("9.")) {
+                console.error("Current Mops CLI only supports pocket-ic 9.x.x and 4.0.0");
                 process.exit(1);
             }
-            this.pocketIcServer = await PocketIcServer.start({
-                showRuntimeLogs: false,
-                showCanisterLogs: false,
-                binPath: pocketIcBin,
-                ttl: this.ttl,
-            });
-            this.pocketIc = await PocketIc.create(this.pocketIcServer.getUrl());
+            // pocket-ic 9.x.x
+            if (config.toolchain?.["pocket-ic"]?.startsWith("9.")) {
+                this.pocketIcServer = await PocketIcServerMops.start({
+                    showRuntimeLogs: false,
+                    showCanisterLogs: false,
+                    binPath: pocketIcBin,
+                    ttl: this.ttl,
+                });
+                this.pocketIc = await PocketIcMops.create(this.pocketIcServer.getUrl());
+            }
+            // pocket-ic 4.0.0
+            else {
+                this.pocketIcServer = await PocketIcServer.start({
+                    showRuntimeLogs: false,
+                    showCanisterLogs: false,
+                    binPath: pocketIcBin,
+                    ttl: this.ttl,
+                });
+                this.pocketIc = await PocketIc.create(this.pocketIcServer.getUrl());
+            }
             // process canister logs
             this._attachCanisterLogHandler(this.pocketIcServer.serverProcess);
         }
     }
     _attachCanisterLogHandler(proc) {
-        let curData = '';
-        proc.stderr.on('data', (data) => {
+        let curData = "";
+        proc.stderr.on("data", (data) => {
             curData = curData + data.toString();
-            if (curData.includes('\n')) {
-                let chunk = curData.split('\n').slice(0, -1).join('\n');
+            if (curData.includes("\n")) {
+                let chunk = curData.split("\n").slice(0, -1).join("\n");
                 let matches = [...chunk.matchAll(/\[Canister ([a-z0-9-]+)\] (.*)/g)];
                 for (let match of matches) {
                     let [, canisterId, msg] = match;
-                    let stream = this.getCanisterStream(canisterId || '');
+                    let stream = this.getCanisterStream(canisterId || "");
                     if (stream) {
                         stream.write(msg);
                     }
                 }
                 if (matches.length) {
-                    curData = curData.split('\n').slice(-1).join('\n');
+                    curData = curData.split("\n").slice(-1).join("\n");
                 }
             }
         });
     }
     async stop(sigint = false) {
-        if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
+        if (this.type === "dfx" || this.type === "dfx-pocket-ic") {
             if (this.dfxProcess) {
                 let killed = this.dfxProcess.kill();
                 if (!killed) {
-                    this.dfxProcess.kill('SIGKILL');
+                    this.dfxProcess.kill("SIGKILL");
                 }
                 // give replica some time to stop
                 let i = 0;
@@ -135,41 +158,59 @@ export class Replica {
         }
     }
     async deploy(name, wasm, idlFactory, cwd = process.cwd(), signal) {
-        if (this.type === 'dfx' || this.type === 'dfx-pocket-ic') {
+        if (this.type === "dfx" || this.type === "dfx-pocket-ic") {
             // prepare dfx.json for current canister
-            let dfxJson = path.join(this.dir, 'dfx.json');
+            let dfxJson = path.join(this.dir, "dfx.json");
             let oldDfxJsonData;
             if (fs.existsSync(dfxJson)) {
                 oldDfxJsonData = JSON.parse(fs.readFileSync(dfxJson).toString());
             }
-            let newDfxJsonData = this.dfxJson(name, name + '.wasm');
+            let newDfxJsonData = this.dfxJson(name, name + ".wasm");
             if (oldDfxJsonData.canisters) {
                 newDfxJsonData.canisters = Object.assign(oldDfxJsonData.canisters, newDfxJsonData.canisters);
             }
             fs.mkdirSync(this.dir, { recursive: true });
             fs.writeFileSync(dfxJson, JSON.stringify(newDfxJsonData, null, 2));
-            await spawnAsync('dfx', ['deploy', name, '--mode', 'reinstall', '--yes', '--identity', 'anonymous'], { cwd: this.dir, signal, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] }).catch((error) => {
-                if (error.code === 'ABORT_ERR') {
-                    return { stderr: '' };
+            await spawnAsync("dfx", [
+                "deploy",
+                name,
+                "--mode",
+                "reinstall",
+                "--yes",
+                "--identity",
+                "anonymous",
+            ], {
+                cwd: this.dir,
+                signal,
+                stdio: this.verbose ? "pipe" : ["pipe", "ignore", "pipe"],
+            }).catch((error) => {
+                if (error.code === "ABORT_ERR") {
+                    return { stderr: "" };
                 }
                 throw error;
             });
             if (signal?.aborted) {
                 return;
             }
-            await spawnAsync('dfx', ['ledger', 'fabricate-cycles', '--canister', name, '--t', '100'], { cwd: this.dir, signal, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] }).catch((error) => {
-                if (error.code === 'ABORT_ERR') {
-                    return { stderr: '' };
+            await spawnAsync("dfx", ["ledger", "fabricate-cycles", "--canister", name, "--t", "100"], {
+                cwd: this.dir,
+                signal,
+                stdio: this.verbose ? "pipe" : ["pipe", "ignore", "pipe"],
+            }).catch((error) => {
+                if (error.code === "ABORT_ERR") {
+                    return { stderr: "" };
                 }
                 throw error;
             });
             if (signal?.aborted) {
                 return;
             }
-            let canisterId = execSync(`dfx canister id ${name}`, { cwd: this.dir }).toString().trim();
+            let canisterId = execSync(`dfx canister id ${name}`, { cwd: this.dir })
+                .toString()
+                .trim();
             let actor = Actor.createActor(idlFactory, {
                 agent: await HttpAgent.create({
-                    host: 'http://127.0.0.1:4945',
+                    host: "http://127.0.0.1:4945",
                     shouldFetchRootKey: true,
                 }),
                 canisterId,
@@ -182,10 +223,9 @@ export class Replica {
             };
         }
         else if (this.pocketIc) {
-            // let {canisterId, actor} = await this.pocketIc.setupCanister(idlFactory, wasm);
             let { canisterId, actor } = await this.pocketIc.setupCanister({
-                idlFactory,
                 wasm,
+                idlFactory,
             });
             if (signal?.aborted) {
                 return;
@@ -216,7 +256,7 @@ export class Replica {
         return this.canisters[name];
     }
     getCanisterId(name) {
-        return this.canisters[name]?.canisterId || '';
+        return this.canisters[name]?.canisterId || "";
     }
     getCanisterStream(canisterId) {
         for (let canister of Object.values(this.canisters)) {
@@ -226,11 +266,11 @@ export class Replica {
         }
         return null;
     }
-    dfxJson(canisterName, wasmPath = 'canister.wasm', didPath = 'canister.did') {
+    dfxJson(canisterName, wasmPath = "canister.wasm", didPath = "canister.did") {
         let canisters = {};
         if (canisterName) {
             canisters[canisterName] = {
-                type: 'custom',
+                type: "custom",
                 wasm: wasmPath,
                 candid: didPath,
             };
@@ -241,13 +281,13 @@ export class Replica {
             dfx: getDfxVersion(),
             defaults: {
                 build: {
-                    packtool: 'mops sources',
+                    packtool: "mops sources",
                 },
             },
             networks: {
                 local: {
-                    type: 'ephemeral',
-                    bind: '127.0.0.1:4945',
+                    type: "ephemeral",
+                    bind: "127.0.0.1:4945",
                 },
             },
         };

package/dist/commands/search.js

@@ -1,12 +1,12 @@
-import process from 'node:process';
-import asTable from 'as-table';
-import chalk from 'chalk';
-import { mainActor } from '../api/actors.js';
+import process from "node:process";
+import asTable from "as-table";
+import chalk from "chalk";
+import { mainActor } from "../api/actors.js";
 export async function search(text) {
     let actor = await mainActor();
     let [packages, _pageCount] = await actor.search(text, [], []);
     if (!packages.length) {
-        console.log('Packages not found');
+        console.log("Packages not found");
         return;
     }
     let ellipsis = (text, max) => {
@@ -14,23 +14,25 @@ export async function search(text) {
             return text;
         }
         else {
-            return text.slice(0, max) + '…';
+            return text.slice(0, max) + "…";
         }
     };
-    let maxNameLength = Math.max(...packages.map(a => a.config.name.length));
+    let maxNameLength = Math.max(...packages.map((a) => a.config.name.length));
     let table = packages.map((item) => {
         return {
             NAME: chalk.bold(item.config.name),
             DESCRIPTION: ellipsis(item.config.description, process.stdout.columns - 40 - maxNameLength),
             VERSION: item.config.version,
-            UPDATED: new Date(Number(item.publication.time / 1000000n)).toISOString().split('T')[0],
+            UPDATED: new Date(Number(item.publication.time / 1000000n))
+                .toISOString()
+                .split("T")[0],
         };
     });
-    console.log('');
+    console.log("");
     console.log(asTable.configure({
-        delimiter: chalk.gray(' | '),
-        dash: chalk.gray('─'),
-        title: t => chalk.gray.bold(t),
+        delimiter: chalk.gray(" | "),
+        dash: chalk.gray("─"),
+        title: (t) => chalk.gray.bold(t),
     })(table));
-    console.log('');
+    console.log("");
 }

package/dist/commands/self.js

@@ -1,63 +1,66 @@
-import process from 'node:process';
-import child_process, { execSync } from 'node:child_process';
-import chalk from 'chalk';
-import { version, globalConfigDir } from '../mops.js';
-import { cleanCache } from '../cache.js';
-import { toolchain } from './toolchain/index.js';
-let url = 'https://x344g-ziaaa-aaaap-abl7a-cai.icp0.io';
+import process from "node:process";
+import child_process, { execSync } from "node:child_process";
+import chalk from "chalk";
+import { version, globalConfigDir } from "../mops.js";
+import { cleanCache } from "../cache.js";
+import { toolchain } from "./toolchain/index.js";
+let url = "https://x344g-ziaaa-aaaap-abl7a-cai.icp0.io";
 function detectPackageManager() {
-    let res = '';
+    let res = "";
     try {
-        res = execSync('which mops').toString();
+        res = execSync("which mops").toString();
     }
     catch (e) { }
     if (!res) {
-        console.error(chalk.red('Couldn\'t detect package manager'));
+        console.error(chalk.red("Couldn't detect package manager"));
         process.exit(1);
     }
-    if (res.includes('pnpm/')) {
-        return 'pnpm';
+    if (res.includes("pnpm/")) {
+        return "pnpm";
     }
     // else if (res.includes('bun/')) {
     // 	return 'bun';
     // }
     else {
-        return 'npm';
+        return "npm";
     }
 }
 export async function getLatestVersion() {
-    let res = await fetch(url + '/tags/latest');
+    let res = await fetch(url + "/tags/latest");
     return res.text();
 }
 export async function update() {
     let latest = await getLatestVersion();
     let current = version();
     if (latest === current) {
-        console.log(chalk.green('You are up to date. Version: ' + current));
+        console.log(chalk.green("You are up to date. Version: " + current));
     }
     else {
-        console.log('Current version: ' + chalk.yellow(current));
-        console.log('Updating to version: ' + chalk.green(latest));
+        console.log("Current version: " + chalk.yellow(current));
+        console.log("Updating to version: " + chalk.green(latest));
         let pm = detectPackageManager();
-        let npmArgs = pm === 'npm' ? ['--no-fund', '--silent'] : [];
-        let proc = child_process.spawn(pm, ['add', '-g', ...npmArgs, `${url}/versions/${latest}.tgz`], { stdio: 'inherit', detached: false });
-        proc.on('exit', (res) => {
+        let npmArgs = pm === "npm" ? ["--no-fund", "--silent"] : [];
+        let proc = child_process.spawn(pm, ["add", "-g", ...npmArgs, `${url}/versions/${latest}.tgz`], { stdio: "inherit", detached: false });
+        proc.on("exit", (res) => {
             if (res !== 0) {
-                console.log(chalk.red('Failed to update.'));
+                console.log(chalk.red("Failed to update."));
                 process.exit(1);
             }
-            console.log(chalk.green('Success'));
+            console.log(chalk.green("Success"));
         });
     }
 }
 export async function uninstall() {
-    console.log('Cleaning cache...');
+    console.log("Cleaning cache...");
     cleanCache();
-    console.log('Resetting toolchain management...');
+    console.log("Resetting toolchain management...");
     toolchain.init({ reset: true, silent: true });
-    console.log('Uninstalling mops CLI...');
+    console.log("Uninstalling mops CLI...");
     let pm = detectPackageManager();
-    child_process.spawn(pm, ['remove', '-g', '--silent', 'ic-mops'], { stdio: 'inherit', detached: false });
-    console.log(chalk.yellow('Config directory has not been deleted: ' + globalConfigDir));
-    console.log('Uninstalled');
+    child_process.spawn(pm, ["remove", "-g", "--silent", "ic-mops"], {
+        stdio: "inherit",
+        detached: false,
+    });
+    console.log(chalk.yellow("Config directory has not been deleted: " + globalConfigDir));
+    console.log("Uninstalled");
 }

package/dist/commands/sources.d.ts

@@ -1,4 +1,8 @@
-export declare function sources({ conflicts, cwd }?: {
+export declare function sourcesArgs({ conflicts, cwd, }?: {
+    conflicts?: "ignore" | "error" | "warning" | undefined;
+    cwd?: string | undefined;
+}): Promise<string[][]>;
+export declare function sources({ conflicts, cwd, }?: {
     conflicts?: "ignore" | "error" | "warning" | undefined;
     cwd?: string | undefined;
 }): Promise<string[]>;

package/dist/commands/sources.js

@@ -1,24 +1,25 @@
-import process from 'node:process';
-import path from 'node:path';
-import fs from 'node:fs';
-import { checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConfig } from '../mops.js';
-import { resolvePackages } from '../resolve-packages.js';
-export async function sources({ conflicts = 'ignore', cwd = process.cwd() } = {}) {
+import process from "node:process";
+import path from "node:path";
+import fs from "node:fs";
+import { checkConfigFile, formatDir, formatGithubDir, getDependencyType, readConfig, } from "../mops.js";
+import { resolvePackages } from "../resolve-packages.js";
+export async function sourcesArgs({ conflicts = "ignore", cwd = process.cwd(), } = {}) {
     if (!checkConfigFile()) {
         return [];
     }
     let resolvedPackages = await resolvePackages({ conflicts });
     // sources
-    return Object.entries(resolvedPackages).map(([name, version]) => {
+    return Object.entries(resolvedPackages)
+        .map(([name, version]) => {
         let depType = getDependencyType(version);
         let pkgDir;
-        if (depType === 'local') {
+        if (depType === "local") {
             pkgDir = path.relative(cwd, version);
         }
-        else if (depType === 'github') {
+        else if (depType === "github") {
             pkgDir = path.relative(cwd, formatGithubDir(name, version));
         }
-        else if (depType === 'mops') {
+        else if (depType === "mops") {
             pkgDir = path.relative(cwd, formatDir(name, version));
         }
         else {
@@ -26,17 +27,22 @@ export async function sources({ conflicts = 'ignore', cwd = process.cwd() } = {}
         }
         // append baseDir
         let pkgBaseDir;
-        if (fs.existsSync(path.join(pkgDir, 'mops.toml'))) {
-            let config = readConfig(path.join(pkgDir, 'mops.toml'));
-            pkgBaseDir = path.join(pkgDir, config.package?.baseDir || 'src');
+        if (fs.existsSync(path.join(pkgDir, "mops.toml"))) {
+            let config = readConfig(path.join(pkgDir, "mops.toml"));
+            pkgBaseDir = path.join(pkgDir, config.package?.baseDir || "src");
         }
         else {
-            pkgBaseDir = path.join(pkgDir, 'src');
+            pkgBaseDir = path.join(pkgDir, "src");
         }
         // use pkgDir if baseDir doesn't exist for local packages
-        if (depType === 'local' && !fs.existsSync(path.resolve(cwd, pkgBaseDir))) {
+        if (depType === "local" &&
+            !fs.existsSync(path.resolve(cwd, pkgBaseDir))) {
             pkgBaseDir = pkgDir;
         }
-        return `--package ${name} ${pkgBaseDir}`;
-    }).filter(x => x != null);
+        return ["--package", name, pkgBaseDir];
+    })
+        .filter((x) => x != null);
+}
+export async function sources({ conflicts = "ignore", cwd = process.cwd(), } = {}) {
+    return (await sourcesArgs({ conflicts, cwd })).map((args) => args.join(" "));
 }

package/dist/commands/sync.d.ts

@@ -1,5 +1,5 @@
 type SyncOptions = {
-    lock?: 'update' | 'ignore';
+    lock?: "update" | "ignore";
 };
 export declare function sync({ lock }?: SyncOptions): Promise<void>;
 export {};