ic-mops 2.6.0 → 2.8.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Next
 
+## 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)
+- `mops publish` now hard-errors on GitHub `[dependencies]` instead of prompting; the backend has rejected them for some time and the prompt was misleading
+- `mops publish` now fails fast with a clear error when unsupported fields (`dfx`, `moc`, `homepage`, `documentation`, `donation`) are set in `mops.toml`
+- Fix `mops publish` reporting incorrect max length for `license` field (was 30, now matches backend limit of 40)
+
 ## 2.6.0
 
 - Packages can ship lintoko rules for consumers in a `rules/` directory (distinct from `lint/`/`lints/` which check the package itself); `rules/*.toml` files are included automatically when running `mops publish`

package/RELEASE.md

@@ -21,33 +21,36 @@ cd cli
 npm version patch --no-git-tag-version  # or: minor / major
 ```
 
-## 3. Create a release PR
+## 3. Create a release PR and enable auto-merge
 
 ```bash
 git checkout -b <username>/release-X.Y.Z
 git add cli/CHANGELOG.md cli/package.json cli/package-lock.json
 git commit -m "release: CLI vX.Y.Z"
 git push -u origin <username>/release-X.Y.Z
-gh pr create --title "release: CLI vX.Y.Z" --body "..."
+gh pr create \
+  --title "release: CLI vX.Y.Z" \
+  --body "Release CLI vX.Y.Z." \
+  --label release
+gh pr merge --auto --squash
 ```
 
-Wait for CI to pass, then merge.
+The [`release-pr.yml`](../.github/workflows/release-pr.yml) workflow runs on every update and validates:
+- PR title matches `release: CLI vX.Y.Z`
+- `cli/CHANGELOG.md` has an entry for the version
+- `cli/package.json` version matches
 
-## 4. Tag and push
+Once all required checks pass the PR merges automatically. On merge, `release-pr.yml` pushes the `cli-vX.Y.Z` tag, which triggers the [`release.yml`](../.github/workflows/release.yml) workflow — it builds, publishes to npm, creates a GitHub Release, and deploys canisters (`cli.mops.one` and `docs.mops.one`).
 
-```bash
-git checkout main && git pull
-git tag cli-vX.Y.Z
-git push origin cli-vX.Y.Z
-```
-
-This triggers the [`release.yml`](../.github/workflows/release.yml) workflow which builds, publishes to npm, creates a GitHub Release, deploys canisters (`cli.mops.one` and `docs.mops.one`), and opens a PR with on-chain release artifacts.
-
-Monitor at [Actions → Release CLI](https://github.com/caffeinelabs/mops/actions/workflows/release.yml).
+> **Note:** This workflow only deploys the `cli` and `docs` canisters. The `main`, `assets`, `blog`, and `play-frontend` canisters require a manual deploy. If a release includes changes to any of those (e.g. `backend/main/` or `frontend/`), upgrade them manually (staging first, then `ic`):
+>
+> ```bash
+> NODE_ENV=production dfx deploy --no-wallet --identity mops --network <staging|ic> <canister>
+> ```
 
-## 5. Merge artifacts PR
+## 5. Artifacts PR
 
-After the workflow completes, merge the `cli-releases: vX.Y.Z artifacts` PR.
+After the release pipeline completes, it creates and auto-merges a `cli-releases: vX.Y.Z artifacts` PR. No action needed unless it fails — monitor at [Actions → Release CLI](https://github.com/caffeinelabs/mops/actions/workflows/release.yml) and merge the artifacts PR manually if needed.
 
 ## Verify build
 

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/publish.ts

@@ -83,7 +83,7 @@ export async function publish(
   }
 
   // desired fields
-  for (let key of ["description", "repository"]) {
+  for (let key of ["description"]) {
     // @ts-ignore
     if (!config.package[key] && !process.env.CI) {
       let res = await prompts({
@@ -120,6 +120,14 @@ export async function publish(
     }
   }
 
+  // disabled fields
+  for (let key of ["dfx", "moc", "homepage", "documentation", "donation"]) {
+    if ((config.package as any)[key]) {
+      console.log(chalk.red("Error: ") + `package.${key} is not supported yet`);
+      process.exit(1);
+    }
+  }
+
   // check lengths
   let keysMax = {
     name: 50,
@@ -130,7 +138,7 @@ export async function publish(
     documentation: 300,
     homepage: 300,
     readme: 100,
-    license: 30,
+    license: 40,
     files: 20,
     dfx: 10,
     moc: 10,
@@ -166,18 +174,12 @@ export async function publish(
     }
 
     for (let dep of Object.values(config.dependencies)) {
-      if (dep.repo && !process.env.CI) {
-        let res = await prompts({
-          type: "confirm",
-          name: "ok",
-          message:
-            chalk.yellow(
-              "GitHub dependencies make the registry less reliable and limit its capabilities.\nIf you are the owner of the dependency, please consider publishing it to the Mops registry.",
-            ) + "\n\nPublish anyway?",
-        });
-        if (!res.ok) {
-          return;
-        }
+      if (dep.repo) {
+        console.log(
+          chalk.red("Error: ") +
+            "GitHub dependencies are no longer supported.\nIf you are the owner of the dependency, please publish it to the Mops registry.",
+        );
+        process.exit(1);
       }
     }
   }
@@ -345,7 +347,10 @@ export async function publish(
   // parse changelog
   console.log("Parsing CHANGELOG.md...");
   let changelog = parseChangelog(config.package.version);
-  if (!changelog && config.package.repository) {
+  if (
+    !changelog &&
+    config.package.repository?.startsWith("https://github.com/")
+  ) {
     console.log("Fetching release notes from GitHub...");
     changelog = await fetchGitHubReleaseNotes(
       config.package.repository,

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/publish.js

@@ -50,7 +50,7 @@ export async function publish(options = {}) {
         }
     }
     // desired fields
-    for (let key of ["description", "repository"]) {
+    for (let key of ["description"]) {
         // @ts-ignore
         if (!config.package[key] && !process.env.CI) {
             let res = await prompts({
@@ -85,6 +85,13 @@ export async function publish(options = {}) {
             process.exit(1);
         }
     }
+    // disabled fields
+    for (let key of ["dfx", "moc", "homepage", "documentation", "donation"]) {
+        if (config.package[key]) {
+            console.log(chalk.red("Error: ") + `package.${key} is not supported yet`);
+            process.exit(1);
+        }
+    }
     // check lengths
     let keysMax = {
         name: 50,
@@ -95,7 +102,7 @@ export async function publish(options = {}) {
         documentation: 300,
         homepage: 300,
         readme: 100,
-        license: 30,
+        license: 40,
         files: 20,
         dfx: 10,
         moc: 10,
@@ -123,15 +130,10 @@ export async function publish(options = {}) {
             delete dep.path;
         }
         for (let dep of Object.values(config.dependencies)) {
-            if (dep.repo && !process.env.CI) {
-                let res = await prompts({
-                    type: "confirm",
-                    name: "ok",
-                    message: chalk.yellow("GitHub dependencies make the registry less reliable and limit its capabilities.\nIf you are the owner of the dependency, please consider publishing it to the Mops registry.") + "\n\nPublish anyway?",
-                });
-                if (!res.ok) {
-                    return;
-                }
+            if (dep.repo) {
+                console.log(chalk.red("Error: ") +
+                    "GitHub dependencies are no longer supported.\nIf you are the owner of the dependency, please publish it to the Mops registry.");
+                process.exit(1);
             }
         }
     }
@@ -272,7 +274,8 @@ export async function publish(options = {}) {
     // parse changelog
     console.log("Parsing CHANGELOG.md...");
     let changelog = parseChangelog(config.package.version);
-    if (!changelog && config.package.repository) {
+    if (!changelog &&
+        config.package.repository?.startsWith("https://github.com/")) {
         console.log("Fetching release notes from GitHub...");
         changelog = await fetchGitHubReleaseNotes(config.package.repository, config.package.version);
     }

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.6.0",
+  "version": "2.8.0",
   "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/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.6.0",
+  "version": "2.8.0",
   "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/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"