ic-mops 2.13.1 → 2.14.0

package/integrity.ts

@@ -41,8 +41,8 @@ export async function checkIntegrity(lock?: "check" | "update" | "ignore") {
   }
 
   if (lock === "update") {
-    await updateLockFile({ force });
-    await checkLockFile(force);
+    let regenerated = await updateLockFile({ force });
+    await checkLockFile(force, regenerated);
   } else if (lock === "check") {
     await checkLockFile(force);
   }
@@ -159,14 +159,16 @@ export function checkLockFileLight(): boolean {
   return false;
 }
 
+// returns true if the lock file was (re)written, false if it was skipped
+// because the existing lock is still valid.
 export async function updateLockFile({
   force = false,
-}: { force?: boolean } = {}) {
+}: { force?: boolean } = {}): Promise<boolean> {
   // if lock file exists and mops.toml hasn't changed, don't update it
   // (unless forced: `--lock update` must unconditionally regenerate so users
   // can recover from a corrupt lockfile without `rm mops.lock`)
   if (!force && checkLockFileLight()) {
-    return;
+    return false;
   }
 
   let resolvedDeps = await resolvePackages();
@@ -201,10 +203,13 @@ export async function updateLockFile({
     console.log("  Applications: commit this file.");
     console.log("  Libraries: add mops.lock to .gitignore.");
   }
+  return true;
 }
 
 // compare hashes of local files with hashes from the lock file
-export async function checkLockFile(force = false) {
+// `regenerated` indicates the lockfile was just rewritten from the registry
+// (via `updateLockFile`), so any remaining hash mismatch must be a local edit.
+export async function checkLockFile(force = false, regenerated = false) {
   let supportedVersions = [1, 2, 3];
   let rootDir = getRootDir();
   let lockFile = path.join(rootDir, "mops.lock");
@@ -318,10 +323,26 @@ export async function checkLockFile(force = false) {
         console.error(`Locked hash: ${lockedHash}`);
         console.error(`Actual hash: ${localHash}`);
         console.error("");
-        console.error(
-          "If you have not modified files under .mops/, your lockfile may be stale or corrupt.",
-        );
-        console.error("Run `mops install --lock update` to regenerate it.");
+        if (regenerated) {
+          // The lock was just rewritten from the registry, so the only way
+          // for a per-file hash to still differ is that .mops/<file> was
+          // edited locally. Point users at the actual fix.
+          let pkgDir = fileId.split("/")[0];
+          console.error(
+            `.mops/${fileId} differs from the registry — your local copy has been modified.`,
+          );
+          console.error(
+            `To restore from the global cache, delete the \`.mops/${pkgDir}\` directory and run \`mops install\`.`,
+          );
+          console.error(
+            "To keep custom changes, use a `repo` or `path` entry in mops.toml instead of editing .mops/ directly.",
+          );
+        } else {
+          console.error(
+            "If you have not modified files under .mops/, your lockfile may be stale or corrupt.",
+          );
+          console.error("Run `mops install --lock update` to regenerate it.");
+        }
         process.exit(1);
       }
     }

package/mops.ts

@@ -2,7 +2,7 @@ import process from "node:process";
 import path from "node:path";
 import fs from "node:fs";
 import { Identity } from "@icp-sdk/core/agent";
-import TOML from "@iarna/toml";
+import TOML from "smol-toml";
 import chalk from "chalk";
 import prompts from "prompts";
 import { decodeFile } from "./pem.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.13.1",
+  "version": "2.14.0",
   "type": "module",
   "bin": {
     "mops": "dist/bin/mops.js",
@@ -50,7 +50,7 @@
     "test": "NODE_OPTIONS=\"--experimental-vm-modules\" jest"
   },
   "dependencies": {
-    "@iarna/toml": "2.2.5",
+    "smol-toml": "1.6.1",
     "@icp-sdk/core": "4.0.2",
     "@noble/hashes": "1.8.0",
     "as-table": "1.0.55",
@@ -114,6 +114,6 @@
     "ts-jest": "29.4.5",
     "tsx": "4.19.2",
     "typescript": "5.9.2",
-    "wasm-pack": "0.13.1"
+    "wasm-pack": "0.15.0"
   }
 }

package/tests/__snapshots__/migrate.test.ts.snap

@@ -143,12 +143,11 @@ exports[`migrate migrate new creates a migration file with timestamp and templat
 }
 `;
 
-exports[`migrate stable check hint stable check fails with hint when deployed.most is incompatible 1`] = `
+exports[`migrate stable check stable check fails when deployed.most is incompatible 1`] = `
 {
   "exitCode": 1,
   "stderr": "(unknown location): Compatibility error [M0169], the stable variable \`a\` of the previous version cannot be implicitly discarded. The variable can only be dropped by an explicit migration function, please see https://internetcomputer.org/docs/motoko/fundamentals/actors/compatibility#explicit-migration-using-a-migration-function
 (unknown location): Compatibility error [M0169], the stable variable \`name\` of the previous version cannot be implicitly discarded. The variable can only be dropped by an explicit migration function, please see https://internetcomputer.org/docs/motoko/fundamentals/actors/compatibility#explicit-migration-using-a-migration-function
-Hint: You may need a migration. Run \`mops migrate new <Name>\` to create one.
 ✗ Stable compatibility check failed for canister 'backend'",
   "stdout": "✓ backend",
 }

package/tests/check-fix.test.ts

@@ -1,6 +1,8 @@
 import { beforeAll, describe, expect, test } from "@jest/globals";
 import { cpSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
 import path from "path";
+import { lock } from "proper-lockfile";
 import { parseDiagnostics } from "../helpers/autofix-motoko";
 import { cli, normalizePaths } from "./helpers";
 
@@ -60,6 +62,13 @@ describe("check --fix", () => {
     return runFilePath;
   }
 
+  test("parseDiagnostics tolerates missing moc output", () => {
+    // execa with reject:false yields undefined stdout when moc fails to spawn
+    // or is killed (e.g. OOM); parsing must degrade to no diagnostics, not throw.
+    expect(parseDiagnostics(undefined)).toEqual([]);
+    expect(parseDiagnostics("")).toEqual([]);
+  });
+
   test("M0223", async () => {
     await testCheckFix("M0223.mo", { M0223: 1 });
   });
@@ -156,4 +165,41 @@ describe("check --fix", () => {
     expect(result.stderr).toMatch(/error/i);
     expect(result.stdout).not.toMatch(/✓ run/);
   });
+
+  test("concurrent --fix runs serialize and produce the same output", async () => {
+    const runFilePath = copyFixture("edit-suggestions.mo");
+    await cli(["check", runFilePath, "--fix", "--", warningFlags], {
+      cwd: fixDir,
+    });
+    const expected = readFileSync(runFilePath, "utf-8");
+    copyFixture("edit-suggestions.mo");
+
+    // Hold the lock from the test process itself so both children
+    // deterministically hit ELOCKED, print "Waiting...", and queue.
+    const lockTarget = path.join(fixDir, ".mops", "fix.lock");
+    await mkdir(path.dirname(lockTarget), { recursive: true });
+    await writeFile(lockTarget, "", { flag: "a" });
+    const release = await lock(lockTarget, { stale: 30_000 });
+
+    const childA = cli(["check", runFilePath, "--fix", "--", warningFlags], {
+      cwd: fixDir,
+    });
+    const childB = cli(["check", runFilePath, "--fix", "--", warningFlags], {
+      cwd: fixDir,
+    });
+
+    // Hold long enough for both children to spawn (`npm run mops` → bundler →
+    // CLI startup) and attempt the non-blocking acquire. 5s is conservative —
+    // local runs land well under 2s, the headroom is purely to absorb CI jitter.
+    await new Promise((r) => setTimeout(r, 5000));
+    await release();
+
+    const [a, b] = await Promise.all([childA, childB]);
+    expect(a.exitCode).toBe(0);
+    expect(b.exitCode).toBe(0);
+    expect(readFileSync(runFilePath, "utf-8")).toBe(expected);
+    // At least one child must have hit the held lock and queued; if neither
+    // did, the lock didn't actually serialize anything.
+    expect(a.stdout + b.stdout).toContain("Waiting for another");
+  });
 });

package/tests/check-stable/migrations-chain/deployed.most

@@ -0,0 +1,14 @@
+// Version: 4.0.0
+{
+  "20250101_000000_Init" : {} -> {a : Nat; b : Text};
+  "20250201_000000_AddField" : (old : {a : Nat; b : Text}) -> {a : Nat; b : Text; c : Bool};
+  "20250301_000000_AddD" : (old : {a : Nat; b : Text; c : Bool}) -> {a : Nat; b : Text; c : Bool; d : Int};
+  "20250401_000000_AddE" : (old : {a : Nat; b : Text; c : Bool; d : Int}) -> {a : Nat; b : Text; c : Bool; d : Int; e : Text}
+}
+actor  {
+  stable a : Nat;
+  stable b : Text;
+  stable c : Bool;
+  stable d : Int;
+  stable e : Text
+};

package/tests/check-stable/migrations-chain/migrations/20250101_000000_Init.mo

@@ -0,0 +1,8 @@
+module {
+  public func migration(_ : {}) : { a : Nat; b : Text } {
+    {
+      a = 42;
+      b = "hello";
+    };
+  };
+};

package/tests/check-stable/migrations-chain/migrations/20250201_000000_AddField.mo

@@ -0,0 +1,9 @@
+module {
+  public func migration(old : { a : Nat; b : Text }) : {
+    a : Nat;
+    b : Text;
+    c : Bool;
+  } {
+    { old with c = true };
+  };
+};

package/tests/check-stable/migrations-chain/migrations/20250301_000000_AddD.mo

@@ -0,0 +1,10 @@
+module {
+  public func migration(old : { a : Nat; b : Text; c : Bool }) : {
+    a : Nat;
+    b : Text;
+    c : Bool;
+    d : Int;
+  } {
+    { old with d = 0 };
+  };
+};

package/tests/check-stable/migrations-chain/migrations/20250401_000000_AddE.mo

@@ -0,0 +1,11 @@
+module {
+  public func migration(old : { a : Nat; b : Text; c : Bool; d : Int }) : {
+    a : Nat;
+    b : Text;
+    c : Bool;
+    d : Int;
+    e : Text;
+  } {
+    { old with e = "" };
+  };
+};

package/tests/check-stable/migrations-chain/mops.toml

@@ -0,0 +1,15 @@
+[toolchain]
+moc = "1.5.0"
+
+[moc]
+args = ["--default-persistent-actors"]
+
+[canisters.backend]
+main = "src/main.mo"
+
+[canisters.backend.migrations]
+chain = "migrations"
+check-limit = 3
+
+[canisters.backend.check-stable]
+path = "deployed.most"

package/tests/check-stable/migrations-chain/src/main.mo

@@ -0,0 +1,13 @@
+import Prim "mo:prim";
+
+actor {
+  let a : Nat;
+  let b : Text;
+  let c : Bool;
+  let d : Int;
+  let e : Text;
+
+  public func check() : async () {
+    Prim.debugPrint(debug_show { a; b; c; d; e });
+  };
+};

package/tests/check-stable.test.ts

@@ -86,4 +86,24 @@ describe("check-stable", () => {
     expect(result.exitCode).toBe(1);
     expect(result.stderr).toMatch(/File not found/);
   });
+
+  // Regression: two concurrent `mops check-stable` runs on the same project used to clobber
+  // each other's `.mops/.check-stable/new.most` and the staged migration symlinks, surfacing
+  // as a misleading `new.most: No such file or directory` or an `EEXIST: symlink` crash.
+  test("concurrent runs do not clobber each other's scratch state", async () => {
+    const cwd = path.join(import.meta.dirname, "check-stable/migrations-chain");
+    const results = await Promise.all(
+      Array.from({ length: 10 }, () => cli(["check-stable"], { cwd })),
+    );
+    for (const result of results) {
+      expect({
+        exitCode: result.exitCode,
+        stderr: result.stderr,
+      }).toEqual({
+        exitCode: 0,
+        stderr: "",
+      });
+      expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    }
+  }, 60_000);
 });

package/tests/check.test.ts

@@ -113,19 +113,20 @@ describe("check", () => {
     expect(result.stdout).toMatch(/Stable compatibility check passed/);
   });
 
-  test("deployed: silently skips when file missing and skipIfMissing", async () => {
+  test("deployed: skips when file missing and skipIfMissing, with deprecation warning", async () => {
     const cwd = path.join(import.meta.dirname, "check/deployed-missing-skip");
     const result = await cli(["check"], { cwd });
     expect(result.exitCode).toBe(0);
     expect(result.stdout).not.toMatch(/stable/i);
+    expect(result.stderr).toMatch(/skipIfMissing.*deprecated/);
   });
 
-  test("deployed: errors when file missing without deployedSkipIfFileMissing", async () => {
+  test("deployed: errors when file missing", async () => {
     const cwd = path.join(import.meta.dirname, "check/deployed-missing-error");
     const result = await cli(["check"], { cwd });
     expect(result.exitCode).toBe(1);
     expect(result.stderr).toMatch(/Deployed file not found/);
-    expect(result.stderr).toMatch(/skipIfMissing/);
+    expect(result.stderr).toMatch(/empty actor/);
   });
 
   test("--fix runs stable check after fixing", async () => {

package/tests/cli.test.ts

@@ -1,5 +1,14 @@
 import { describe, expect, jest, test } from "@jest/globals";
-import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
 import path from "path";
 import { cli, normalizePaths } from "./helpers";
 
@@ -128,6 +137,108 @@ describe("install", () => {
       rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
     }
   });
+
+  // Regression: when a file under `.mops/` was edited locally (an unsupported
+  // but common AI-agent workflow), `--lock update` would regenerate the
+  // lockfile from registry hashes, then fail the per-file check, and tell the
+  // user to "Run `mops install --lock update` to regenerate it" — the exact
+  // command that just failed. The post-regen message now says the local copy
+  // was modified and points at the actual fix.
+  test("--lock update flags a locally edited .mops/ file with a clear recovery hint", async () => {
+    const cwd = path.join(import.meta.dirname, "install/success");
+    const lockFile = path.join(cwd, "mops.lock");
+    const localDep = path.join(cwd, ".mops", "core@1.0.0", "mops.toml");
+    rmSync(lockFile, { force: true });
+    rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+    try {
+      const first = await cli(["install"], { cwd, env: { CI: undefined } });
+      expect(first.exitCode).toBe(0);
+      expect(existsSync(localDep)).toBe(true);
+
+      writeFileSync(
+        localDep,
+        readFileSync(localDep, "utf8") + "\n# tampered\n",
+      );
+
+      const result = await cli(["install", "--lock", "update"], {
+        cwd,
+        env: { CI: undefined },
+      });
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toMatch(
+        /\.mops\/core@1\.0\.0\/mops\.toml differs from the registry/,
+      );
+      expect(result.stderr).toMatch(
+        /delete the `\.mops\/core@1\.0\.0` directory and run `mops install`/,
+      );
+      expect(result.stderr).not.toMatch(/Run `mops install --lock update`/);
+    } finally {
+      rmSync(lockFile, { force: true });
+      rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+    }
+  });
+
+  // Regression: parallel `mops install` runs against the same project used to
+  // race in two places — global cache writes (`.mops/<pkg>` populated mid-write)
+  // and local `.mops/<pkg>` copies — leaving zero-byte / partially-written
+  // files. We isolate the global cache via `XDG_CACHE_HOME` so the global-write
+  // path actually executes (cold-cache scenario).
+  test("parallel `mops install` produces a complete .mops tree (no zero-byte / staging dirs)", async () => {
+    const cwd = path.join(import.meta.dirname, "install/success");
+    const lockFile = path.join(cwd, "mops.lock");
+    const localCache = path.join(cwd, ".mops");
+    const xdgCache = mkdtempSync(path.join(tmpdir(), "mops-test-xdg-"));
+    rmSync(lockFile, { force: true });
+    rmSync(localCache, { recursive: true, force: true });
+    try {
+      const N = 5;
+      const env = { CI: undefined, XDG_CACHE_HOME: xdgCache };
+      const runs = await Promise.all(
+        Array.from({ length: N }, () => cli(["install"], { cwd, env })),
+      );
+      for (const r of runs) {
+        if (r.exitCode !== 0) {
+          throw new Error(
+            `mops install exited ${r.exitCode}\nstdout:\n${r.stdout}\nstderr:\n${r.stderr}`,
+          );
+        }
+      }
+
+      const walk = (dir: string): string[] => {
+        const out: string[] = [];
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          const p = path.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            out.push(...walk(p));
+          } else if (entry.isFile()) {
+            out.push(p);
+          }
+        }
+        return out;
+      };
+      const files = walk(localCache);
+      const empties = files.filter((f) => statSync(f).size === 0);
+      expect(empties).toEqual([]);
+
+      const stagingLeftovers = readdirSync(localCache).filter((e) =>
+        e.startsWith(".staging-"),
+      );
+      expect(stagingLeftovers).toEqual([]);
+
+      const globalPkg = path.join(
+        xdgCache,
+        "mops",
+        "packages",
+        "core@1.0.0",
+        "mops.toml",
+      );
+      expect(existsSync(globalPkg)).toBe(true);
+    } finally {
+      rmSync(lockFile, { force: true });
+      rmSync(localCache, { recursive: true, force: true });
+      rmSync(xdgCache, { recursive: true, force: true });
+    }
+  });
 });
 
 // `mops update` and `mops outdated` default to caret-bound resolution: stay
@@ -214,3 +325,71 @@ describe("update / outdated bounds", () => {
     }
   });
 });
+
+// `--patch` restricts updates to patch versions only, never crossing the minor
+// bound. Fixture pins `core = "2.3.0"`; registry has 2.3.1 (patch) and 2.4.0,
+// 2.5.0 (minor). Caret default lets minors through; --patch must not.
+describe("update / outdated --patch bound", () => {
+  jest.setTimeout(120_000);
+
+  const cwd = path.join(import.meta.dirname, "install/update-bound-patch");
+  const tomlFile = path.join(cwd, "mops.toml");
+  const original = readFileSync(tomlFile, "utf8");
+
+  const cleanup = () => {
+    rmSync(path.join(cwd, "mops.lock"), { force: true });
+    rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+    writeFileSync(tomlFile, original);
+  };
+
+  const coreVersion = (toml: string) =>
+    toml.match(/core = "(\d+\.\d+\.\d+)"/)?.[1];
+
+  test("mops update --patch restricts to patch bumps", async () => {
+    cleanup();
+    try {
+      await cli(["install"], { cwd, env: { CI: undefined } });
+      const result = await cli(["update", "--patch"], {
+        cwd,
+        env: { CI: undefined },
+      });
+      expect(result.exitCode).toBe(0);
+      const after = readFileSync(tomlFile, "utf8");
+      // Stays within 2.3.x — must not cross to 2.4.0 / 2.5.0
+      expect(coreVersion(after)).toMatch(/^2\.3\./);
+      expect(coreVersion(after)).not.toBe("2.3.0");
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("mops outdated --patch reports patch-only updates", async () => {
+    cleanup();
+    try {
+      await cli(["install"], { cwd, env: { CI: undefined } });
+      const patch = normalizePaths(
+        (await cli(["outdated", "--patch"], { cwd, env: { CI: undefined } }))
+          .stdout,
+      );
+      // Only 2.3.x updates surface, never 2.4.x / 2.5.x
+      expect(patch).toMatch(/core 2\.3\.0 -> 2\.3\./);
+      expect(patch).not.toMatch(/core 2\.3\.0 -> 2\.[4-9]/);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test.each([["update"], ["outdated"]])(
+    "mops %s rejects --major + --patch",
+    async (cmd) => {
+      const result = await cli([cmd, "--major", "--patch"], {
+        cwd,
+        env: { CI: undefined },
+      });
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toMatch(
+        /option '--major' cannot be used with option '--patch'/,
+      );
+    },
+  );
+});

package/tests/helpers.ts

@@ -37,7 +37,11 @@ export const normalizePaths = (text: string): string => {
       .replace(/\/[^\s"]+\/\.cache\/mops/g, "<CACHE>")
       .replace(/\/[^\s"]+\/Library\/Caches\/mops/g, "<CACHE>")
       .replace(/\/[^\s"[\]]+\/moc(?:-wrapper)?(?=\s|$)/g, "moc-wrapper")
-      .replace(/\/[^\s"[\]]+\.motoko\/bin\/moc/g, "moc-wrapper"),
+      .replace(/\/[^\s"[\]]+\.motoko\/bin\/moc/g, "moc-wrapper")
+      // Per-invocation scratch / staging dirs use mkdtemp; redact the random suffix
+      // (Node's exact suffix format isn't a stable contract) so snapshots stay stable.
+      .replace(/\.mops\/\.check-stable-\w+/g, ".mops/.check-stable")
+      .replace(/(\.migrations-[\w.-]+?)-\w+(?=[/\s"]|$)/g, "$1"),
   );
 };
 

package/tests/install/update-bound-patch/mops.toml

@@ -0,0 +1,2 @@
+[dependencies]
+core = "2.3.0"

package/tests/migrate.test.ts

@@ -241,8 +241,8 @@ describe("migrate", () => {
     });
   });
 
-  describe("stable check hint", () => {
-    test("stable check fails with hint when deployed.most is incompatible", async () => {
+  describe("stable check", () => {
+    test("stable check fails when deployed.most is incompatible", async () => {
       const cwd = await makeTempFixture("basic");
       await writeFile(
         path.join(cwd, "deployed.most"),

package/types.ts

@@ -49,6 +49,7 @@ export type CanisterConfig = {
   initArg?: string;
   "check-stable"?: {
     path: string;
+    /** @deprecated Create the file with an empty actor instead. */
     skipIfMissing?: boolean;
   };
   migrations?: MigrationsConfig;