ic-mops 2.15.0 → 2.15.1

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Next
 
+## 2.15.1
+
+- `mops check --fix` no longer aborts when a fixable file is read-only (e.g. a frozen migration chain file deliberately `chmod`'d to remove write access). The autofixer now skips such files with a warning and continues fixing the rest, instead of crashing the whole run on `EACCES`/`EPERM`.
+
+- Load the PocketIC client lazily, only when a command actually starts a replica. Commands like `mops check`, `mops build`, and `mops install` no longer pay to load it (and its `@icp-sdk/core` dependency) at startup. This also unblocks running the CLI via `tsx` in local dev, where `pic-js-mops` (shipped as ESM without `"type": "module"`) fails to resolve as a static import.
+
+- `mops bench --verbose` is now actually verbose. It prints the benchmark pipeline up front — compiler version, replica + version, GC, profile, and whether the wasm is optimized (`dfx` post-optimizes with `optimize: "cycles"` via ic-wasm on deploy; `pocket-ic` runs the raw `moc` output) — logs the full `moc` build command, and streams the compiler and `dfx` output instead of capturing and discarding it. Notably this surfaces dfx's `WARNING: Failed to optimize the Wasm module`, which dfx prints (and then silently deploys the unoptimized module) when `optimize: "cycles"` fails — e.g. on multi-value modules that the bundled ic-wasm can't process. Previously all of this was hidden even with `--verbose`.
+
 ## 2.15.0
 
 - Fix `mops check --fix` corrupting source on lines containing multi-byte UTF-8 characters (e.g. `Char.toNat32('京')` dropping its trailing `)`). The autofixer was feeding moc's UTF-8 byte columns into LSP's UTF-16 position API, mis-applying every edit past the first non-ASCII byte on the line. When moc emits `byte_start`/`byte_end` (1.10.0 and newer) the fixer now applies edits byte-accurately; older moc still falls back to the line+column path (unchanged behavior, still ASCII-only).

package/cli.ts

@@ -543,7 +543,12 @@ program
     ),
   )
   // .addOption(new Option('--force-gc', 'Force GC'))
-  .addOption(new Option("--verbose", "Show more information"))
+  .addOption(
+    new Option(
+      "--verbose",
+      "Print the benchmark pipeline (compiler, replica, GC, optimization) and stream compiler/replica output, including dfx optimization warnings",
+    ),
+  )
   .action(async (filter, options) => {
     checkConfigFile(true);
     await installAll({

package/commands/bench-replica.ts

@@ -74,7 +74,8 @@ export class BenchReplica {
     if (this.type === "dfx" || this.type === "dfx-pocket-ic") {
       await execaCommand(
         `dfx deploy ${name} --mode reinstall --yes --identity anonymous`,
-        { cwd, stdio: this.verbose ? "pipe" : ["pipe", "ignore", "pipe"] },
+        // `inherit` so dfx output is streamed under --verbose (incl. its `Failed to optimize` warning)
+        { cwd, stdio: this.verbose ? "inherit" : ["pipe", "ignore", "pipe"] },
       );
       let canisterId = execSync(`dfx canister id ${name}`, { cwd })
         .toString()

package/commands/bench.ts

@@ -101,7 +101,28 @@ export async function bench(
 
   warnIfDfxReplica(replicaType, optionsArg.replica === "dfx");
 
-  options.verbose && console.log(options);
+  if (options.verbose) {
+    // `dfx` post-optimizes the wasm on deploy (`optimize: "cycles"`, via ic-wasm);
+    // `pocket-ic` runs the raw moc output. This changes instruction counts, so surface it.
+    let optimize =
+      replicaType === "dfx" || replicaType === "dfx-pocket-ic"
+        ? 'dfx `optimize: "cycles"` (ic-wasm) on deploy'
+        : "none (raw moc output)";
+    console.log(chalk.gray("Benchmark pipeline:"));
+    console.log(chalk.gray(`  compiler:  moc ${options.compilerVersion}`));
+    console.log(
+      chalk.gray(
+        `  replica:   ${replicaType}${options.replicaVersion ? ` ${options.replicaVersion}` : ""}`,
+      ),
+    );
+    console.log(
+      chalk.gray(
+        `  gc:        ${options.gc}${options.forceGc ? " (forced)" : ""}`,
+      ),
+    );
+    console.log(chalk.gray(`  profile:   ${options.profile}`));
+    console.log(chalk.gray(`  optimize:  ${optimize}`));
+  }
 
   let replica = new BenchReplica(replicaType, options.verbose);
 
@@ -303,14 +324,16 @@ async function deployBenchFile(
   // build canister
   let mocPath = getMocPath();
   let mocArgs = getMocArgs(options);
-  options.verbose && console.time(`build ${canisterName}`);
-  await execaCommand(
-    `${mocPath} -c --idl canister.mo ${globalMocArgs.join(" ")} ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`,
-    {
-      cwd: tempDir,
-      stdio: options.verbose ? "pipe" : ["pipe", "ignore", "pipe"],
-    },
-  );
+  let buildCmd = `${mocPath} -c --idl canister.mo ${globalMocArgs.join(" ")} ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`;
+  if (options.verbose) {
+    console.log(chalk.gray(`[${canisterName}] ${buildCmd}`));
+    console.time(`build ${canisterName}`);
+  }
+  await execaCommand(buildCmd, {
+    cwd: tempDir,
+    // `inherit` so the compiler output (warnings/errors) is streamed under --verbose
+    stdio: options.verbose ? "inherit" : ["pipe", "ignore", "pipe"],
+  });
   options.verbose && console.timeEnd(`build ${canisterName}`);
 
   // deploy canister

package/dist/cli.js

@@ -393,7 +393,7 @@ program
     .addOption(new Option("--save", "Save benchmark results to .bench/<filename>.json"))
     .addOption(new Option("--compare", "Run benchmark and compare results with .bench/<filename>.json"))
     // .addOption(new Option('--force-gc', 'Force GC'))
-    .addOption(new Option("--verbose", "Show more information"))
+    .addOption(new Option("--verbose", "Print the benchmark pipeline (compiler, replica, GC, optimization) and stream compiler/replica output, including dfx optimization warnings"))
     .action(async (filter, options) => {
     checkConfigFile(true);
     await installAll({

package/dist/commands/bench-replica.js

@@ -55,7 +55,9 @@ export class BenchReplica {
     }
     async deploy(name, wasm, cwd = process.cwd()) {
         if (this.type === "dfx" || this.type === "dfx-pocket-ic") {
-            await execaCommand(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, { cwd, stdio: this.verbose ? "pipe" : ["pipe", "ignore", "pipe"] });
+            await execaCommand(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, 
+            // `inherit` so dfx output is streamed under --verbose (incl. its `Failed to optimize` warning)
+            { cwd, stdio: this.verbose ? "inherit" : ["pipe", "ignore", "pipe"] });
             let canisterId = execSync(`dfx canister id ${name}`, { cwd })
                 .toString()
                 .trim();

package/dist/commands/bench.js

@@ -61,7 +61,19 @@ export async function bench(filter = "", optionsArg = {}) {
         options.replicaVersion = config.toolchain?.["pocket-ic"] || "";
     }
     warnIfDfxReplica(replicaType, optionsArg.replica === "dfx");
-    options.verbose && console.log(options);
+    if (options.verbose) {
+        // `dfx` post-optimizes the wasm on deploy (`optimize: "cycles"`, via ic-wasm);
+        // `pocket-ic` runs the raw moc output. This changes instruction counts, so surface it.
+        let optimize = replicaType === "dfx" || replicaType === "dfx-pocket-ic"
+            ? 'dfx `optimize: "cycles"` (ic-wasm) on deploy'
+            : "none (raw moc output)";
+        console.log(chalk.gray("Benchmark pipeline:"));
+        console.log(chalk.gray(`  compiler:  moc ${options.compilerVersion}`));
+        console.log(chalk.gray(`  replica:   ${replicaType}${options.replicaVersion ? ` ${options.replicaVersion}` : ""}`));
+        console.log(chalk.gray(`  gc:        ${options.gc}${options.forceGc ? " (forced)" : ""}`));
+        console.log(chalk.gray(`  profile:   ${options.profile}`));
+        console.log(chalk.gray(`  optimize:  ${optimize}`));
+    }
     let replica = new BenchReplica(replicaType, options.verbose);
     let rootDir = getRootDir();
     let globStr = "**/bench?(mark)/**/*.bench.mo";
@@ -207,10 +219,15 @@ async function deployBenchFile(file, options, replica, globalMocArgs) {
     // build canister
     let mocPath = getMocPath();
     let mocArgs = getMocArgs(options);
-    options.verbose && console.time(`build ${canisterName}`);
-    await execaCommand(`${mocPath} -c --idl canister.mo ${globalMocArgs.join(" ")} ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`, {
+    let buildCmd = `${mocPath} -c --idl canister.mo ${globalMocArgs.join(" ")} ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`;
+    if (options.verbose) {
+        console.log(chalk.gray(`[${canisterName}] ${buildCmd}`));
+        console.time(`build ${canisterName}`);
+    }
+    await execaCommand(buildCmd, {
         cwd: tempDir,
-        stdio: options.verbose ? "pipe" : ["pipe", "ignore", "pipe"],
+        // `inherit` so the compiler output (warnings/errors) is streamed under --verbose
+        stdio: options.verbose ? "inherit" : ["pipe", "ignore", "pipe"],
     });
     options.verbose && console.timeEnd(`build ${canisterName}`);
     // deploy canister

package/dist/helpers/autofix-motoko.js

@@ -1,5 +1,6 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
+import chalk from "chalk";
 import { execa } from "execa";
 import { TextDocument } from "vscode-languageserver-textdocument";
 export function parseDiagnostics(stdout) {
@@ -110,6 +111,9 @@ function applyDiagnosticFixes(content, fixes) {
 const MAX_FIX_ITERATIONS = 10;
 export async function autofixMotoko(mocPath, files, mocArgs) {
     const fixedFilesCodes = new Map();
+    // Frozen migration files are often chmod'd read-only; warn once and skip
+    // them rather than aborting the whole run on EACCES/EPERM.
+    const readOnlySkipped = new Set();
     for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
         const fixesByFile = new Map();
         for (const file of files) {
@@ -126,12 +130,25 @@ export async function autofixMotoko(mocPath, files, mocArgs) {
         }
         let progress = false;
         for (const [file, fixes] of fixesByFile) {
+            if (readOnlySkipped.has(file)) {
+                continue;
+            }
             const original = await readFile(file, "utf-8");
             const { text: result, appliedCodes } = applyDiagnosticFixes(original, fixes);
             if (result === original) {
                 continue;
             }
-            await writeFile(file, result, "utf-8");
+            try {
+                await writeFile(file, result, "utf-8");
+            }
+            catch (err) {
+                if (err?.code === "EACCES" || err?.code === "EPERM") {
+                    readOnlySkipped.add(file);
+                    console.warn(chalk.yellow(`Skipped read-only file ${relative(process.cwd(), file)} (${appliedCodes.length} fix(es) not applied)`));
+                    continue;
+                }
+                throw err;
+            }
             progress = true;
             const existing = fixedFilesCodes.get(file) ?? [];
             existing.push(...appliedCodes);

package/dist/helpers/pocket-ic-client.d.ts

@@ -1,5 +1,5 @@
-import { PocketIc, PocketIcServer } from "pic-ic";
-import { PocketIc as PocketIcModern, PocketIcServer as PocketIcServerModern, type StartServerOptions } from "pic-js-mops";
+import type { PocketIc, PocketIcServer } from "pic-ic";
+import type { PocketIc as PocketIcModern, PocketIcServer as PocketIcServerModern, StartServerOptions } from "pic-js-mops";
 export type AnyPocketIcServer = PocketIcServer | PocketIcServerModern;
 export type AnyPocketIc = PocketIc | PocketIcModern;
 export type AnySetupCanister = PocketIc["setupCanister"] & PocketIcModern["setupCanister"];

package/dist/helpers/pocket-ic-client.js

@@ -1,18 +1,22 @@
 import semver from "semver";
-import { PocketIc, PocketIcServer } from "pic-ic";
-import { PocketIc as PocketIcModern, PocketIcServer as PocketIcServerModern, } from "pic-js-mops";
 import { readConfig } from "../mops.js";
 function isLegacy() {
     let version = readConfig().toolchain?.["pocket-ic"];
     return !!version && !!semver.valid(version) && semver.lt(version, "9.0.0");
 }
 export async function startPocketIc(options) {
+    // Imported lazily so commands that never start a replica don't load the
+    // PocketIC client. `pic-js-mops` ships ESM without `type: module`, which a
+    // static import fails to resolve under tsx (local dev); a dynamic import
+    // resolves it on every platform.
     if (isLegacy()) {
+        const { PocketIc, PocketIcServer } = await import("pic-ic");
         let server = await PocketIcServer.start(options);
         let client = await PocketIc.create(server.getUrl());
         return { server, client };
     }
-    let server = await PocketIcServerModern.start(options);
-    let client = await PocketIcModern.create(server.getUrl());
+    const { PocketIc, PocketIcServer } = await import("pic-js-mops");
+    let server = await PocketIcServer.start(options);
+    let client = await PocketIc.create(server.getUrl());
     return { server, client };
 }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.15.0",
+  "version": "2.15.1",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",

package/dist/tests/check-fix.test.js

@@ -1,5 +1,5 @@
 import { beforeAll, describe, expect, test } from "@jest/globals";
-import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { chmodSync, cpSync, readdirSync, readFileSync, unlinkSync, } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "path";
 import { lock } from "proper-lockfile";
@@ -19,7 +19,9 @@ describe("check --fix", () => {
     const diagnosticFlags = [warningFlags, "--error-format=json"];
     beforeAll(() => {
         for (const file of readdirSync(runDir).filter((f) => f.endsWith(".mo"))) {
-            unlinkSync(path.join(runDir, file));
+            const p = path.join(runDir, file);
+            chmodSync(p, 0o644);
+            unlinkSync(p);
         }
     });
     function copyFixture(file) {
@@ -86,6 +88,16 @@ describe("check --fix", () => {
         expect(fixResult.stdout).toContain("1 fix applied");
         expect(readFileSync(runFilePath, "utf-8")).not.toContain("<Nat>");
     });
+    test("read-only file is skipped, not crashed", async () => {
+        const runFilePath = copyFixture("M0223.mo");
+        const before = readFileSync(runFilePath, "utf-8");
+        chmodSync(runFilePath, 0o444);
+        const result = await cli(["check", runFilePath, "--fix", "--", warningFlags], { cwd: fixDir });
+        expect(result.exitCode).toBe(0);
+        expect(result.stderr).toMatch(/Skipped read-only file/);
+        // File left untouched since the fix couldn't be written.
+        expect(readFileSync(runFilePath, "utf-8")).toBe(before);
+    });
     test("verbose", async () => {
         const result = await cli(["check", "Ok.mo", "--fix", "--verbose"], {
             cwd: fixDir,

package/helpers/autofix-motoko.ts

@@ -1,5 +1,6 @@
 import { readFile, writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
+import chalk from "chalk";
 import { execa } from "execa";
 import { TextDocument } from "vscode-languageserver-textdocument";
 
@@ -186,6 +187,9 @@ export async function autofixMotoko(
   mocArgs: string[],
 ): Promise<AutofixResult | null> {
   const fixedFilesCodes = new Map<string, string[]>();
+  // Frozen migration files are often chmod'd read-only; warn once and skip
+  // them rather than aborting the whole run on EACCES/EPERM.
+  const readOnlySkipped = new Set<string>();
 
   for (let iteration = 0; iteration < MAX_FIX_ITERATIONS; iteration++) {
     const fixesByFile = new Map<string, DiagnosticFix[]>();
@@ -212,6 +216,10 @@ export async function autofixMotoko(
     let progress = false;
 
     for (const [file, fixes] of fixesByFile) {
+      if (readOnlySkipped.has(file)) {
+        continue;
+      }
+
       const original = await readFile(file, "utf-8");
       const { text: result, appliedCodes } = applyDiagnosticFixes(
         original,
@@ -222,7 +230,20 @@ export async function autofixMotoko(
         continue;
       }
 
-      await writeFile(file, result, "utf-8");
+      try {
+        await writeFile(file, result, "utf-8");
+      } catch (err: any) {
+        if (err?.code === "EACCES" || err?.code === "EPERM") {
+          readOnlySkipped.add(file);
+          console.warn(
+            chalk.yellow(
+              `Skipped read-only file ${relative(process.cwd(), file)} (${appliedCodes.length} fix(es) not applied)`,
+            ),
+          );
+          continue;
+        }
+        throw err;
+      }
       progress = true;
 
       const existing = fixedFilesCodes.get(file) ?? [];

package/helpers/pocket-ic-client.ts

@@ -1,9 +1,9 @@
 import semver from "semver";
-import { PocketIc, PocketIcServer } from "pic-ic";
-import {
+import type { PocketIc, PocketIcServer } from "pic-ic";
+import type {
   PocketIc as PocketIcModern,
   PocketIcServer as PocketIcServerModern,
-  type StartServerOptions,
+  StartServerOptions,
 } from "pic-js-mops";
 import { readConfig } from "../mops.js";
 
@@ -20,13 +20,19 @@ function isLegacy(): boolean {
 export async function startPocketIc(
   options: StartServerOptions,
 ): Promise<{ server: AnyPocketIcServer; client: AnyPocketIc }> {
+  // Imported lazily so commands that never start a replica don't load the
+  // PocketIC client. `pic-js-mops` ships ESM without `type: module`, which a
+  // static import fails to resolve under tsx (local dev); a dynamic import
+  // resolves it on every platform.
   if (isLegacy()) {
+    const { PocketIc, PocketIcServer } = await import("pic-ic");
     let server = await PocketIcServer.start(options);
     let client = await PocketIc.create(server.getUrl());
     return { server, client };
   }
 
-  let server = await PocketIcServerModern.start(options);
-  let client = await PocketIcModern.create(server.getUrl());
+  const { PocketIc, PocketIcServer } = await import("pic-js-mops");
+  let server = await PocketIcServer.start(options);
+  let client = await PocketIc.create(server.getUrl());
   return { server, client };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.15.0",
+  "version": "2.15.1",
   "type": "module",
   "bin": {
     "mops": "dist/bin/mops.js",

package/tests/check-fix.test.ts

@@ -1,5 +1,11 @@
 import { beforeAll, describe, expect, test } from "@jest/globals";
-import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import {
+  chmodSync,
+  cpSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+} from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "path";
 import { lock } from "proper-lockfile";
@@ -22,7 +28,9 @@ describe("check --fix", () => {
 
   beforeAll(() => {
     for (const file of readdirSync(runDir).filter((f) => f.endsWith(".mo"))) {
-      unlinkSync(path.join(runDir, file));
+      const p = path.join(runDir, file);
+      chmodSync(p, 0o644);
+      unlinkSync(p);
     }
   });
 
@@ -132,6 +140,22 @@ describe("check --fix", () => {
     expect(readFileSync(runFilePath, "utf-8")).not.toContain("<Nat>");
   });
 
+  test("read-only file is skipped, not crashed", async () => {
+    const runFilePath = copyFixture("M0223.mo");
+    const before = readFileSync(runFilePath, "utf-8");
+    chmodSync(runFilePath, 0o444);
+
+    const result = await cli(
+      ["check", runFilePath, "--fix", "--", warningFlags],
+      { cwd: fixDir },
+    );
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stderr).toMatch(/Skipped read-only file/);
+    // File left untouched since the fix couldn't be written.
+    expect(readFileSync(runFilePath, "utf-8")).toBe(before);
+  });
+
   test("verbose", async () => {
     const result = await cli(["check", "Ok.mo", "--fix", "--verbose"], {
       cwd: fixDir,