ic-mops 2.13.2 → 2.14.1

package/tests/check.test.ts

@@ -15,6 +15,17 @@ describe("check", () => {
     await cliSnapshot(["check", "Ok.mo", "Error.mo"], { cwd }, 1);
   });
 
+  // The verbose snapshot shows a single "moc ... [both files]" line, proving the
+  // whole set is checked in one invocation rather than one moc call per file.
+  test("multiple files in a single invocation", async () => {
+    const cwd = path.join(import.meta.dirname, "check/success");
+    await cliSnapshot(
+      ["check", "Ok.mo", "Warning.mo", "--verbose"],
+      { cwd },
+      0,
+    );
+  });
+
   test("warning", async () => {
     const cwd = path.join(import.meta.dirname, "check/success");
     const result = await cliSnapshot(["check", "Warning.mo"], { cwd }, 0);

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/install/update-bound-patch/mops.toml

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

package/vessel.ts

@@ -2,20 +2,28 @@ import process from "node:process";
 import {
   existsSync,
   mkdirSync,
+  mkdtempSync,
+  rmSync,
   createWriteStream,
   readFileSync,
   writeFileSync,
 } from "node:fs";
 import path from "node:path";
 import { pipeline } from "node:stream";
-import { deleteSync } from "del";
 import { execaCommand } from "execa";
 import chalk from "chalk";
 import { createLogUpdate } from "log-update";
 import got from "got";
 import decompress from "decompress";
-import { parseGithubURL, progressBar } from "./mops.js";
-import { getDepCacheDir, getGithubDepCacheName, isDepCached } from "./cache.js";
+import { getRootDir, parseGithubURL, progressBar } from "./mops.js";
+import {
+  commitStagingDir,
+  createStagingDir,
+  getDepCacheDir,
+  getGithubDepCacheName,
+  isDepCached,
+  sweepStaleStagingDirs,
+} from "./cache.js";
 
 const dhallFileToJson = async (filePath: string, silent: boolean) => {
   if (existsSync(filePath)) {
@@ -130,18 +138,23 @@ export const downloadFromGithub = async (
 
       // Prevent `onError` being called twice.
       readStream.off("error", reject);
-      const tmpDir = path.resolve(process.cwd(), ".mops/_tmp/");
+
+      // Per-invocation download dir (was a shared `.mops/_tmp/` clobbered
+      // by concurrent github installs). `.staging-` prefix lets the sweeper
+      // pick up leftovers from a crashed download.
+      const parentTmp = path.resolve(getRootDir(), ".mops");
+      mkdirSync(parentTmp, { recursive: true });
+      const tmpDir = mkdtempSync(path.join(parentTmp, ".staging-github-dl-"));
       const tmpFile = path.resolve(
         tmpDir,
         `${gitName}@${(commitHash || branch).replaceAll("/", "___")}.zip`,
       );
+      const cleanup = () => rmSync(tmpDir, { recursive: true, force: true });
 
       try {
-        mkdirSync(tmpDir, { recursive: true });
-
         pipeline(readStream, createWriteStream(tmpFile), (err) => {
           if (err) {
-            deleteSync([tmpDir]);
+            cleanup();
             reject(err);
           } else {
             let options = {
@@ -153,17 +166,17 @@ export const downloadFromGithub = async (
             };
             decompress(tmpFile, dest, options)
               .then((unzippedFiles) => {
-                deleteSync([tmpDir]);
+                cleanup();
                 resolve(unzippedFiles);
               })
               .catch((err) => {
-                deleteSync([tmpDir]);
+                cleanup();
                 reject(err);
               });
           }
         });
       } catch (err) {
-        deleteSync([tmpDir]);
+        cleanup();
         reject(err);
       }
     });
@@ -182,6 +195,8 @@ export const installFromGithub = async (
     ignoreTransitive = false,
   } = {},
 ): Promise<boolean> => {
+  sweepStaleStagingDirs();
+
   let cacheName = getGithubDepCacheName(name, repo);
   let cacheDir = getDepCacheDir(cacheName);
 
@@ -199,12 +214,14 @@ export const installFromGithub = async (
 
     progress(0, 1024 * 500);
 
-    mkdirSync(cacheDir, { recursive: true });
-
+    // Stage download in a sibling dir; previously `mkdirSync(cacheDir)`
+    // before download made empty dirs look cached to peers.
+    let stagingDir = createStagingDir(cacheDir);
     try {
-      await downloadFromGithub(repo, cacheDir, progress);
+      await downloadFromGithub(repo, stagingDir, progress);
+      commitStagingDir(stagingDir, cacheDir);
     } catch (err) {
-      deleteSync([cacheDir], { force: true });
+      rmSync(stagingDir, { recursive: true, force: true });
       return false;
     }
   }

package/wasm/pkg/nodejs/package.json

@@ -11,4 +11,4 @@
   ],
   "main": "wasm.js",
   "types": "wasm.d.ts"
-}
+}

package/wasm/pkg/web/package.json

@@ -15,4 +15,4 @@
   "sideEffects": [
     "./snippets/*"
   ]
-}
+}