ic-mops 2.7.0 → 2.8.1

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Next
 
+## 2.8.1
+
+- Fix `mops check-stable` failing when `[moc] args` contains flags with relative paths (e.g. `--actor-idl=system-idl`)
+
+## 2.8.0
+
+- `mops build` now generates a `.most` (Motoko stable types) file alongside `.wasm` and `.did` for each canister; the `.most` file can be passed directly to `mops check-stable` to verify upgrade compatibility
+- `mops.lock` is now created automatically the first time dependencies are installed — no need to run `mops i --lock update` once to opt in. Triggered by `mops install`, `mops add`, `mops remove`, `mops update`, `mops sync`, and `mops init` (when it installs dependencies). Applications should commit `mops.lock`; library authors should add it to `.gitignore`.
+
 ## 2.7.0
 
 - `mops publish` no longer requires a `repository` field — it is now optional metadata (used by the registry UI for source links)

package/commands/build.ts

@@ -69,9 +69,11 @@ export async function build(
     }
     motokoPath = resolveConfigPath(motokoPath);
     const wasmPath = join(outputDir, `${canisterName}.wasm`);
+    const mostPath = join(outputDir, `${canisterName}.most`);
     let args = [
       "-c",
       "--idl",
+      "--stable-types",
       "-o",
       wasmPath,
       motokoPath,
@@ -116,6 +118,9 @@ export async function build(
         console.log(result.stdout);
       }
 
+      options.verbose &&
+        console.log(chalk.gray(`Stable types written to ${mostPath}`));
+
       const generatedDidPath = join(outputDir, `${canisterName}.did`);
       const resolvedCandidPath = canister.candid
         ? resolveConfigPath(canister.candid)
@@ -188,6 +193,7 @@ const managedFlags: Record<string, string> = {
   "-o": "use [build].outputDir in mops.toml or --output flag instead",
   "-c": "this flag is always set by mops build",
   "--idl": "this flag is always set by mops build",
+  "--stable-types": "this flag is always set by mops build",
   "--public-metadata": "this flag is managed by mops build",
 };
 

package/commands/check-stable.ts

@@ -1,6 +1,6 @@
-import { basename, join, relative, resolve } from "node:path";
+import { basename, join } from "node:path";
 import { existsSync, mkdirSync } from "node:fs";
-import { rename, rm } from "node:fs/promises";
+import { rm } from "node:fs/promises";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
@@ -62,8 +62,7 @@ export async function runStableCheck(
     options = {},
   } = params;
 
-  const checkStableDir = resolve(CHECK_STABLE_DIR);
-  const sources = (await sourcesArgs({ cwd: checkStableDir })).flat();
+  const sources = (await sourcesArgs()).flat();
   const isOldMostFile = oldFile.endsWith(".most");
 
   if (!existsSync(oldFile)) {
@@ -137,10 +136,13 @@ async function generateStableTypes(
   globalMocArgs: string[],
   options: Partial<CheckStableOptions>,
 ): Promise<string> {
-  const relFile = relative(resolve(CHECK_STABLE_DIR), resolve(moFile));
+  const base = basename(outputPath, ".most");
+  const wasmPath = join(CHECK_STABLE_DIR, base + ".wasm");
   const args = [
     "--stable-types",
-    relFile,
+    "-o",
+    wasmPath,
+    moFile,
     ...sources,
     ...globalMocArgs,
     ...(options.extraArgs ?? []),
@@ -155,7 +157,6 @@ async function generateStableTypes(
   }
 
   const result = await execa(mocPath, args, {
-    cwd: CHECK_STABLE_DIR,
     stdio: "pipe",
     reject: false,
   });
@@ -169,9 +170,7 @@ async function generateStableTypes(
     );
   }
 
-  const base = basename(moFile, ".mo");
-  await rename(join(CHECK_STABLE_DIR, base + ".most"), outputPath);
-  await rm(join(CHECK_STABLE_DIR, base + ".wasm"), { force: true });
+  await rm(wasmPath, { force: true });
 
   return outputPath;
 }

package/dist/commands/build.js

@@ -45,9 +45,11 @@ export async function build(canisterNames, options) {
         }
         motokoPath = resolveConfigPath(motokoPath);
         const wasmPath = join(outputDir, `${canisterName}.wasm`);
+        const mostPath = join(outputDir, `${canisterName}.most`);
         let args = [
             "-c",
             "--idl",
+            "--stable-types",
             "-o",
             wasmPath,
             motokoPath,
@@ -84,6 +86,8 @@ export async function build(canisterNames, options) {
             if (options.verbose && result.stdout && result.stdout.trim()) {
                 console.log(result.stdout);
             }
+            options.verbose &&
+                console.log(chalk.gray(`Stable types written to ${mostPath}`));
             const generatedDidPath = join(outputDir, `${canisterName}.did`);
             const resolvedCandidPath = canister.candid
                 ? resolveConfigPath(canister.candid)
@@ -132,6 +136,7 @@ const managedFlags = {
     "-o": "use [build].outputDir in mops.toml or --output flag instead",
     "-c": "this flag is always set by mops build",
     "--idl": "this flag is always set by mops build",
+    "--stable-types": "this flag is always set by mops build",
     "--public-metadata": "this flag is managed by mops build",
 };
 function collectExtraArgs(config, canister, canisterName, extraArgs) {

package/dist/commands/check-stable.js

@@ -1,6 +1,6 @@
-import { basename, join, relative, resolve } from "node:path";
+import { basename, join } from "node:path";
 import { existsSync, mkdirSync } from "node:fs";
-import { rename, rm } from "node:fs/promises";
+import { rm } from "node:fs/promises";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
@@ -28,8 +28,7 @@ export async function checkStable(oldFile, canisterName, options = {}) {
 }
 export async function runStableCheck(params) {
     const { oldFile, canisterMain, canisterName, mocPath, globalMocArgs, options = {}, } = params;
-    const checkStableDir = resolve(CHECK_STABLE_DIR);
-    const sources = (await sourcesArgs({ cwd: checkStableDir })).flat();
+    const sources = (await sourcesArgs()).flat();
     const isOldMostFile = oldFile.endsWith(".most");
     if (!existsSync(oldFile)) {
         cliError(`File not found: ${oldFile}`);
@@ -65,10 +64,13 @@ export async function runStableCheck(params) {
     }
 }
 async function generateStableTypes(mocPath, moFile, outputPath, sources, globalMocArgs, options) {
-    const relFile = relative(resolve(CHECK_STABLE_DIR), resolve(moFile));
+    const base = basename(outputPath, ".most");
+    const wasmPath = join(CHECK_STABLE_DIR, base + ".wasm");
     const args = [
         "--stable-types",
-        relFile,
+        "-o",
+        wasmPath,
+        moFile,
         ...sources,
         ...globalMocArgs,
         ...(options.extraArgs ?? []),
@@ -78,7 +80,6 @@ async function generateStableTypes(mocPath, moFile, outputPath, sources, globalM
         console.log(chalk.gray(mocPath, JSON.stringify(args)));
     }
     const result = await execa(mocPath, args, {
-        cwd: CHECK_STABLE_DIR,
         stdio: "pipe",
         reject: false,
     });
@@ -88,8 +89,6 @@ async function generateStableTypes(mocPath, moFile, outputPath, sources, globalM
         }
         cliError(`Failed to generate stable types for ${moFile} (exit code: ${result.exitCode})`);
     }
-    const base = basename(moFile, ".mo");
-    await rename(join(CHECK_STABLE_DIR, base + ".most"), outputPath);
-    await rm(join(CHECK_STABLE_DIR, base + ".wasm"), { force: true });
+    await rm(wasmPath, { force: true });
     return outputPath;
 }

package/dist/integrity.js

@@ -9,13 +9,8 @@ import { resolvePackages } from "./resolve-packages.js";
 import { getPackageId } from "./helpers/get-package-id.js";
 export async function checkIntegrity(lock) {
     let force = !!lock;
-    if (!lock &&
-        !process.env["CI"] &&
-        fs.existsSync(path.join(getRootDir(), "mops.lock"))) {
-        lock = "update";
-    }
     if (!lock) {
-        lock = process.env["CI"] ? "check" : "ignore";
+        lock = process.env["CI"] ? "check" : "update";
     }
     if (lock === "update") {
         await updateLockFile();
@@ -133,7 +128,13 @@ export async function updateLockFile() {
     };
     let rootDir = getRootDir();
     let lockFile = path.join(rootDir, "mops.lock");
+    let isNew = !fs.existsSync(lockFile);
     fs.writeFileSync(lockFile, JSON.stringify(lockFileJson, null, 2));
+    if (isNew) {
+        console.log("mops.lock created.");
+        console.log("  Applications: commit this file.");
+        console.log("  Libraries: add mops.lock to .gitignore.");
+    }
 }
 // compare hashes of local files with hashes from the lock file
 export async function checkLockFile(force = false) {

package/dist/package.json

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

package/dist/tests/build.test.js

@@ -42,12 +42,14 @@ describe("build", () => {
         const customOut = path.join(cwd, "custom-out");
         const customWasm = path.join(customOut, "main.wasm");
         const customDid = path.join(customOut, "main.did");
+        const customMost = path.join(customOut, "main.most");
         const defaultDid = path.join(cwd, ".mops/.build/main.did");
         try {
             const result = await cli(["build"], { cwd });
             expect(result.exitCode).toBe(0);
             expect(existsSync(customWasm)).toBe(true);
             expect(existsSync(customDid)).toBe(true);
+            expect(existsSync(customMost)).toBe(true);
             expect(existsSync(defaultDid)).toBe(false);
         }
         finally {
@@ -66,6 +68,7 @@ describe("build", () => {
             expect(result.exitCode).toBe(0);
             expect(existsSync(path.join(outputDir, "foo.wasm"))).toBe(true);
             expect(existsSync(path.join(outputDir, "foo.did"))).toBe(true);
+            expect(existsSync(path.join(outputDir, "foo.most"))).toBe(true);
         }
         finally {
             cleanFixture(cwd, outputDir);
@@ -76,7 +79,7 @@ describe("build", () => {
         const artifact = path.join(cwd, "x");
         const artifactDid = path.join(cwd, "x.did");
         try {
-            await cliSnapshot(["build", "foo", "--", "-o", "x", "-c", "--idl"], { cwd }, 1);
+            await cliSnapshot(["build", "foo", "--", "-o", "x", "-c", "--idl", "--stable-types"], { cwd }, 1);
         }
         finally {
             cleanFixture(cwd, artifact, artifactDid);

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "@jest/globals";
+import { existsSync } from "node:fs";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "path";
@@ -42,6 +43,16 @@ describe("check-stable", () => {
             await rm(tempDir, { recursive: true, force: true });
         }
     });
+    test("works with relative paths in moc args (e.g. --actor-idl)", async () => {
+        const cwd = path.join(import.meta.dirname, "check-stable/actor-idl");
+        const result = await cli(["check-stable", "old.mo"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/Stable compatibility check passed/);
+        expect(existsSync(path.join(cwd, "old.most"))).toBe(false);
+        expect(existsSync(path.join(cwd, "old.wasm"))).toBe(false);
+        expect(existsSync(path.join(cwd, "new.most"))).toBe(false);
+        expect(existsSync(path.join(cwd, "new.wasm"))).toBe(false);
+    });
     test("errors when old file does not exist", async () => {
         const cwd = path.join(import.meta.dirname, "check-stable/compatible");
         const result = await cli(["check-stable", "nonexistent.mo"], { cwd });

package/dist/tests/cli.test.js

@@ -1,4 +1,6 @@
-import { describe, expect, test } from "@jest/globals";
+import { describe, expect, jest, test } from "@jest/globals";
+import { existsSync, rmSync } from "node:fs";
+import path from "path";
 import { cli } from "./helpers";
 describe("cli", () => {
     test("--version", async () => {
@@ -8,3 +10,61 @@ describe("cli", () => {
         expect((await cli(["--help"])).stdout).toMatch(/^Usage: mops/m);
     });
 });
+describe("install", () => {
+    jest.setTimeout(120_000);
+    test("creates mops.lock automatically on first install", async () => {
+        const cwd = path.join(import.meta.dirname, "install/success");
+        const lockFile = path.join(cwd, "mops.lock");
+        rmSync(lockFile, { force: true });
+        try {
+            // Unset CI so checkIntegrity uses the local default ("update")
+            const result = await cli(["install"], { cwd, env: { CI: undefined } });
+            expect(result.exitCode).toBe(0);
+            expect(existsSync(lockFile)).toBe(true);
+            expect(result.stdout).toMatch(/mops\.lock created/);
+        }
+        finally {
+            rmSync(lockFile, { force: true });
+            rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+        }
+    });
+    test("does not print 'mops.lock created' on subsequent installs", async () => {
+        const cwd = path.join(import.meta.dirname, "install/success");
+        const lockFile = path.join(cwd, "mops.lock");
+        rmSync(lockFile, { force: true });
+        try {
+            // Unset CI so checkIntegrity uses the local default ("update")
+            const first = await cli(["install"], { cwd, env: { CI: undefined } });
+            expect(first.exitCode).toBe(0);
+            expect(first.stdout).toMatch(/mops\.lock created/);
+            const result = await cli(["install"], { cwd, env: { CI: undefined } });
+            expect(result.exitCode).toBe(0);
+            expect(existsSync(lockFile)).toBe(true);
+            expect(result.stdout).not.toMatch(/mops\.lock created/);
+        }
+        finally {
+            rmSync(lockFile, { force: true });
+            rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+        }
+    });
+    test("does not create mops.lock when --lock ignore is passed", async () => {
+        const cwd = path.join(import.meta.dirname, "install/success");
+        const lockFile = path.join(cwd, "mops.lock");
+        rmSync(lockFile, { force: true });
+        try {
+            // Unset CI for consistency; --lock ignore bypasses auto-detection regardless
+            const result = await cli(["install", "--lock", "ignore"], {
+                cwd,
+                env: { CI: undefined },
+            });
+            expect(result.exitCode).toBe(0);
+            expect(existsSync(lockFile)).toBe(false);
+        }
+        finally {
+            rmSync(lockFile, { force: true });
+            rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+        }
+    });
+    // mops add/remove/update/sync are not separately tested here because they
+    // all route through the same checkIntegrity code path tested above.
+});

package/dist/tests/helpers.d.ts

@@ -1,7 +1,8 @@
 export interface CliOptions {
     cwd?: string;
+    env?: Record<string, string | undefined>;
 }
-export declare const cli: (args: string[], { cwd }?: CliOptions) => Promise<import("execa").Result<{
+export declare const cli: (args: string[], { cwd, env }?: CliOptions) => Promise<import("execa").Result<{
     stdio: "pipe";
     reject: false;
     cwd?: string | undefined;

package/dist/tests/helpers.js

@@ -6,12 +6,12 @@ import { fileURLToPath } from "url";
 // directly rather than the npm script. This exercises the real global-install
 // code path where the binary lives outside the project tree.
 const useGlobalBinary = Boolean(process.env.MOPS_TEST_GLOBAL);
-export const cli = async (args, { cwd } = {}) => {
+export const cli = async (args, { cwd, env } = {}) => {
     const [cmd, cmdArgs] = useGlobalBinary
         ? ["mops", args]
         : ["npm", ["run", "--silent", "mops", "--", ...args]];
     return await execa(cmd, cmdArgs, {
-        env: { ...process.env, ...(cwd != null && { MOPS_CWD: cwd }) },
+        env: { ...process.env, ...(cwd != null && { MOPS_CWD: cwd }), ...env },
         ...(cwd != null && { cwd }),
         stdio: "pipe",
         reject: false,

package/integrity.ts

@@ -36,16 +36,8 @@ type LockFile = LockFileV1 | LockFileV2 | LockFileV3;
 export async function checkIntegrity(lock?: "check" | "update" | "ignore") {
   let force = !!lock;
 
-  if (
-    !lock &&
-    !process.env["CI"] &&
-    fs.existsSync(path.join(getRootDir(), "mops.lock"))
-  ) {
-    lock = "update";
-  }
-
   if (!lock) {
-    lock = process.env["CI"] ? "check" : "ignore";
+    lock = process.env["CI"] ? "check" : "update";
   }
 
   if (lock === "update") {
@@ -197,7 +189,13 @@ export async function updateLockFile() {
 
   let rootDir = getRootDir();
   let lockFile = path.join(rootDir, "mops.lock");
+  let isNew = !fs.existsSync(lockFile);
   fs.writeFileSync(lockFile, JSON.stringify(lockFileJson, null, 2));
+  if (isNew) {
+    console.log("mops.lock created.");
+    console.log("  Applications: commit this file.");
+    console.log("  Libraries: add mops.lock to .gitignore.");
+  }
 }
 
 // compare hashes of local files with hashes from the lock file

package/package.json

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

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

@@ -5,7 +5,8 @@ exports[`build error 1`] = `
   "exitCode": 0,
   "stderr": "",
   "stdout": "build canister foo
-moc-wrapper ["-c","--idl","-o",".mops/.build/foo.wasm","src/Foo.mo","--package","core",".mops/core@1.0.0/src","--release","--public-metadata","candid:service","--public-metadata","candid:args"]
+moc-wrapper ["-c","--idl","--stable-types","-o",".mops/.build/foo.wasm","src/Foo.mo","--package","core",".mops/core@1.0.0/src","--release","--public-metadata","candid:service","--public-metadata","candid:args"]
+Stable types written to .mops/.build/foo.most
 Adding metadata to .mops/.build/foo.wasm
 
 ✓ Built 1 canister successfully",
@@ -34,10 +35,12 @@ exports[`build ok 1`] = `
   "exitCode": 0,
   "stderr": "",
   "stdout": "build canister foo
-moc-wrapper ["-c","--idl","-o",".mops/.build/foo.wasm","src/Foo.mo","--package","core",".mops/core@1.0.0/src","--release","--public-metadata","candid:service","--public-metadata","candid:args"]
+moc-wrapper ["-c","--idl","--stable-types","-o",".mops/.build/foo.wasm","src/Foo.mo","--package","core",".mops/core@1.0.0/src","--release","--public-metadata","candid:service","--public-metadata","candid:args"]
+Stable types written to .mops/.build/foo.most
 Adding metadata to .mops/.build/foo.wasm
 build canister bar
-moc-wrapper ["-c","--idl","-o",".mops/.build/bar.wasm","src/Bar.mo","--package","core",".mops/core@1.0.0/src","--release","--incremental-gc","--public-metadata","candid:service","--public-metadata","candid:args"]
+moc-wrapper ["-c","--idl","--stable-types","-o",".mops/.build/bar.wasm","src/Bar.mo","--package","core",".mops/core@1.0.0/src","--release","--incremental-gc","--public-metadata","candid:service","--public-metadata","candid:args"]
+Stable types written to .mops/.build/bar.most
 Candid compatibility check passed for canister bar
 Adding metadata to .mops/.build/bar.wasm
 
@@ -82,6 +85,7 @@ exports[`build warns when args contain managed flags 1`] = `
   "stderr": "Warning: '-o' in args for canister foo may conflict with mops build — use [build].outputDir in mops.toml or --output flag instead
 Warning: '-c' in args for canister foo may conflict with mops build — this flag is always set by mops build
 Warning: '--idl' in args for canister foo may conflict with mops build — this flag is always set by mops build
+Warning: '--stable-types' in args for canister foo may conflict with mops build — this flag is always set by mops build
 Error while compiling canister foo
 ENOENT: no such file or directory, open '.mops/.build/foo.did'",
   "stdout": "build canister foo",

package/tests/build.test.ts

@@ -50,6 +50,7 @@ describe("build", () => {
     const customOut = path.join(cwd, "custom-out");
     const customWasm = path.join(customOut, "main.wasm");
     const customDid = path.join(customOut, "main.did");
+    const customMost = path.join(customOut, "main.most");
     const defaultDid = path.join(cwd, ".mops/.build/main.did");
 
     try {
@@ -57,6 +58,7 @@ describe("build", () => {
       expect(result.exitCode).toBe(0);
       expect(existsSync(customWasm)).toBe(true);
       expect(existsSync(customDid)).toBe(true);
+      expect(existsSync(customMost)).toBe(true);
       expect(existsSync(defaultDid)).toBe(false);
     } finally {
       cleanFixture(cwd, customOut);
@@ -76,6 +78,7 @@ describe("build", () => {
       expect(result.exitCode).toBe(0);
       expect(existsSync(path.join(outputDir, "foo.wasm"))).toBe(true);
       expect(existsSync(path.join(outputDir, "foo.did"))).toBe(true);
+      expect(existsSync(path.join(outputDir, "foo.most"))).toBe(true);
     } finally {
       cleanFixture(cwd, outputDir);
     }
@@ -88,7 +91,7 @@ describe("build", () => {
 
     try {
       await cliSnapshot(
-        ["build", "foo", "--", "-o", "x", "-c", "--idl"],
+        ["build", "foo", "--", "-o", "x", "-c", "--idl", "--stable-types"],
         { cwd },
         1,
       );

package/tests/check-stable/actor-idl/mops.toml

@@ -0,0 +1,8 @@
+[toolchain]
+moc = "1.3.0"
+
+[moc]
+args = ["--default-persistent-actors", "--actor-idl=system-idl"]
+
+[canisters.backend]
+main = "new.mo"

package/tests/check-stable/actor-idl/new.mo

@@ -0,0 +1,6 @@
+import IC "ic:aaaaa-aa";
+
+actor {
+  var counter : Nat = 0;
+  var name : Text = "";
+};

package/tests/check-stable/actor-idl/old.mo

@@ -0,0 +1,5 @@
+import IC "ic:aaaaa-aa";
+
+actor {
+  var counter : Nat = 0;
+};

package/tests/check-stable/actor-idl/system-idl/aaaaa-aa.did

@@ -0,0 +1,3 @@
+service ic : {
+  raw_rand : () -> (blob);
+};

package/tests/check-stable.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "@jest/globals";
+import { existsSync } from "node:fs";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "path";
@@ -47,6 +48,17 @@ describe("check-stable", () => {
     }
   });
 
+  test("works with relative paths in moc args (e.g. --actor-idl)", async () => {
+    const cwd = path.join(import.meta.dirname, "check-stable/actor-idl");
+    const result = await cli(["check-stable", "old.mo"], { cwd });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    expect(existsSync(path.join(cwd, "old.most"))).toBe(false);
+    expect(existsSync(path.join(cwd, "old.wasm"))).toBe(false);
+    expect(existsSync(path.join(cwd, "new.most"))).toBe(false);
+    expect(existsSync(path.join(cwd, "new.wasm"))).toBe(false);
+  });
+
   test("errors when old file does not exist", async () => {
     const cwd = path.join(import.meta.dirname, "check-stable/compatible");
     const result = await cli(["check-stable", "nonexistent.mo"], { cwd });

package/tests/cli.test.ts

@@ -1,4 +1,6 @@
-import { describe, expect, test } from "@jest/globals";
+import { describe, expect, jest, test } from "@jest/globals";
+import { existsSync, rmSync } from "node:fs";
+import path from "path";
 import { cli } from "./helpers";
 
 describe("cli", () => {
@@ -10,3 +12,63 @@ describe("cli", () => {
     expect((await cli(["--help"])).stdout).toMatch(/^Usage: mops/m);
   });
 });
+
+describe("install", () => {
+  jest.setTimeout(120_000);
+
+  test("creates mops.lock automatically on first install", async () => {
+    const cwd = path.join(import.meta.dirname, "install/success");
+    const lockFile = path.join(cwd, "mops.lock");
+    rmSync(lockFile, { force: true });
+    try {
+      // Unset CI so checkIntegrity uses the local default ("update")
+      const result = await cli(["install"], { cwd, env: { CI: undefined } });
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(lockFile)).toBe(true);
+      expect(result.stdout).toMatch(/mops\.lock created/);
+    } finally {
+      rmSync(lockFile, { force: true });
+      rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+    }
+  });
+
+  test("does not print 'mops.lock created' on subsequent installs", async () => {
+    const cwd = path.join(import.meta.dirname, "install/success");
+    const lockFile = path.join(cwd, "mops.lock");
+    rmSync(lockFile, { force: true });
+    try {
+      // Unset CI so checkIntegrity uses the local default ("update")
+      const first = await cli(["install"], { cwd, env: { CI: undefined } });
+      expect(first.exitCode).toBe(0);
+      expect(first.stdout).toMatch(/mops\.lock created/);
+      const result = await cli(["install"], { cwd, env: { CI: undefined } });
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(lockFile)).toBe(true);
+      expect(result.stdout).not.toMatch(/mops\.lock created/);
+    } finally {
+      rmSync(lockFile, { force: true });
+      rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+    }
+  });
+
+  test("does not create mops.lock when --lock ignore is passed", async () => {
+    const cwd = path.join(import.meta.dirname, "install/success");
+    const lockFile = path.join(cwd, "mops.lock");
+    rmSync(lockFile, { force: true });
+    try {
+      // Unset CI for consistency; --lock ignore bypasses auto-detection regardless
+      const result = await cli(["install", "--lock", "ignore"], {
+        cwd,
+        env: { CI: undefined },
+      });
+      expect(result.exitCode).toBe(0);
+      expect(existsSync(lockFile)).toBe(false);
+    } finally {
+      rmSync(lockFile, { force: true });
+      rmSync(path.join(cwd, ".mops"), { recursive: true, force: true });
+    }
+  });
+
+  // mops add/remove/update/sync are not separately tested here because they
+  // all route through the same checkIntegrity code path tested above.
+});

package/tests/helpers.ts

@@ -5,6 +5,7 @@ import { fileURLToPath } from "url";
 
 export interface CliOptions {
   cwd?: string;
+  env?: Record<string, string | undefined>;
 }
 
 // When MOPS_TEST_GLOBAL is set, invoke the globally-installed `mops` binary
@@ -12,12 +13,12 @@ export interface CliOptions {
 // code path where the binary lives outside the project tree.
 const useGlobalBinary = Boolean(process.env.MOPS_TEST_GLOBAL);
 
-export const cli = async (args: string[], { cwd }: CliOptions = {}) => {
+export const cli = async (args: string[], { cwd, env }: CliOptions = {}) => {
   const [cmd, cmdArgs] = useGlobalBinary
     ? ["mops", args]
     : ["npm", ["run", "--silent", "mops", "--", ...args]];
   return await execa(cmd, cmdArgs, {
-    env: { ...process.env, ...(cwd != null && { MOPS_CWD: cwd }) },
+    env: { ...process.env, ...(cwd != null && { MOPS_CWD: cwd }), ...env },
     ...(cwd != null && { cwd }),
     stdio: "pipe",
     reject: false,

package/tests/install/success/mops.toml

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