ic-mops 2.8.1 → 2.10.0

package/dist/commands/check.js

@@ -1,13 +1,12 @@
 import path from "node:path";
-import { existsSync } from "node:fs";
 import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
 import { getGlobalMocArgs, getRootDir, readConfig, resolveConfigPath, } from "../mops.js";
 import { autofixMotoko } from "../helpers/autofix-motoko.js";
 import { getMocSemVer } from "../helpers/get-moc-version.js";
-import { resolveCanisterConfigs, resolveCanisterEntrypoints, } from "../helpers/resolve-canisters.js";
-import { runStableCheck } from "./check-stable.js";
+import { filterCanisters, looksLikeFile, resolveCanisterConfigs, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
+import { resolveStablePath, runStableCheck } from "./check-stable.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
 import { collectLintRules, lint } from "./lint.js";
@@ -16,35 +15,137 @@ function supportsAllLibsFlag() {
     const version = getMocSemVer();
     return version ? version.compare(MOC_ALL_LIBS_MIN_VERSION) >= 0 : false;
 }
-export async function check(files, options = {}) {
-    const explicitFiles = Array.isArray(files) ? files : files ? [files] : [];
-    let fileList = [...explicitFiles];
-    const config = readConfig();
-    if (fileList.length === 0) {
-        fileList = resolveCanisterEntrypoints(config).map(resolveConfigPath);
-    }
-    if (fileList.length === 0) {
-        cliError("No Motoko files specified and no canisters defined in mops.toml.\n" +
-            "Either pass files: mops check <files...>\n" +
-            "Or define canisters in mops.toml:\n\n" +
-            "  [canisters.backend]\n" +
-            '  main = "src/main.mo"');
-    }
-    const mocPath = await toolchain.bin("moc", { fallback: true });
-    const sources = await sourcesArgs();
-    const globalMocArgs = getGlobalMocArgs(config);
-    // --all-libs enables richer diagnostics with edit suggestions from moc (requires moc >= 1.3.0)
+function checkAllLibsSupport(verbose) {
     const allLibs = supportsAllLibsFlag();
     if (!allLibs) {
         console.log(chalk.yellow(`moc < ${MOC_ALL_LIBS_MIN_VERSION}: some diagnostic hints may be missing`));
     }
-    else if (options.verbose) {
+    else if (verbose) {
         console.log(chalk.blue("check"), chalk.gray("Using --all-libs for richer diagnostics"));
     }
+    return allLibs;
+}
+function logAutofixResult(fixResult, verbose) {
+    if (fixResult) {
+        for (const [file, codes] of fixResult.fixedFiles) {
+            const unique = [...new Set(codes)].sort();
+            const n = codes.length;
+            const rel = path.relative(process.cwd(), file);
+            console.log(chalk.green(`Fixed ${rel} (${n} ${n === 1 ? "fix" : "fixes"}: ${unique.join(", ")})`));
+        }
+        const fileCount = fixResult.fixedFiles.size;
+        console.log(chalk.green(`\n✓ ${fixResult.totalFixCount} ${fixResult.totalFixCount === 1 ? "fix" : "fixes"} applied to ${fileCount} ${fileCount === 1 ? "file" : "files"}`));
+    }
+    else if (verbose) {
+        console.log(chalk.yellow("No fixes were needed"));
+    }
+}
+export async function check(args, options = {}) {
+    const config = readConfig();
+    const canisters = resolveCanisterConfigs(config);
+    const hasCanisters = Object.keys(canisters).length > 0;
+    const fileArgs = args.filter(looksLikeFile);
+    const nonFileArgs = args.filter((a) => !looksLikeFile(a));
+    const isFileMode = fileArgs.length > 0;
+    if (isFileMode && nonFileArgs.length > 0) {
+        cliError(`Cannot mix file paths and canister names: ${args.join(", ")}\n` +
+            "Pass either file paths (e.g. mops check src/main.mo) or canister names (e.g. mops check backend)");
+    }
+    if (isFileMode) {
+        await checkFiles(config, fileArgs, options);
+    }
+    else {
+        if (!hasCanisters) {
+            cliError("No canisters defined in mops.toml.\n" +
+                "Either pass files: mops check <files...>\n" +
+                "Or define canisters in mops.toml:\n\n" +
+                "  [canisters.backend]\n" +
+                '  main = "src/main.mo"');
+        }
+        const canisterNames = args.length > 0 ? args : undefined;
+        const filtered = filterCanisters(canisters, canisterNames);
+        await checkCanisters(config, filtered, options);
+    }
+    if (config.toolchain?.lintoko) {
+        const rootDir = getRootDir();
+        const lintRules = await collectLintRules(config, rootDir);
+        const lintFiles = isFileMode ? fileArgs : undefined;
+        await lint(undefined, {
+            verbose: options.verbose,
+            fix: options.fix,
+            rules: lintRules,
+            files: lintFiles,
+        });
+    }
+}
+async function checkCanisters(config, canisters, options) {
+    const mocPath = await toolchain.bin("moc", { fallback: true });
+    const sources = (await sourcesArgs()).flat();
+    const globalMocArgs = getGlobalMocArgs(config);
+    const allLibs = checkAllLibsSupport(options.verbose);
+    for (const [canisterName, canister] of Object.entries(canisters)) {
+        if (!canister.main) {
+            cliError(`No main file specified for canister '${canisterName}' in mops.toml`);
+        }
+        validateCanisterArgs(canister, canisterName);
+        const motokoPath = resolveConfigPath(canister.main);
+        const mocArgs = [
+            "--check",
+            ...(allLibs ? ["--all-libs"] : []),
+            ...sources,
+            ...globalMocArgs,
+            ...(canister.args ?? []),
+            ...(options.extraArgs ?? []),
+        ];
+        if (options.fix) {
+            if (options.verbose) {
+                console.log(chalk.blue("check"), chalk.gray(`Attempting to fix ${canisterName}`));
+            }
+            const fixResult = await autofixMotoko(mocPath, [motokoPath], mocArgs);
+            logAutofixResult(fixResult, options.verbose);
+        }
+        try {
+            const args = [motokoPath, ...mocArgs];
+            if (options.verbose) {
+                console.log(chalk.blue("check"), chalk.gray(`Checking canister ${canisterName}:`));
+                console.log(chalk.gray(mocPath, JSON.stringify(args)));
+            }
+            const result = await execa(mocPath, args, {
+                stdio: "inherit",
+                reject: false,
+            });
+            if (result.exitCode !== 0) {
+                cliError(`✗ Check failed for canister ${canisterName} (exit code: ${result.exitCode})`);
+            }
+            console.log(chalk.green(`✓ ${canisterName}`));
+        }
+        catch (err) {
+            cliError(`Error while checking canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
+        }
+        const stablePath = resolveStablePath(canister, canisterName);
+        if (stablePath) {
+            await runStableCheck({
+                oldFile: stablePath,
+                canisterMain: motokoPath,
+                canisterName,
+                mocPath,
+                globalMocArgs,
+                canisterArgs: canister.args ?? [],
+                sources,
+                options: { verbose: options.verbose, extraArgs: options.extraArgs },
+            });
+        }
+    }
+}
+async function checkFiles(config, files, options) {
+    const mocPath = await toolchain.bin("moc", { fallback: true });
+    const sources = (await sourcesArgs()).flat();
+    const globalMocArgs = getGlobalMocArgs(config);
+    const allLibs = checkAllLibsSupport(options.verbose);
     const mocArgs = [
         "--check",
         ...(allLibs ? ["--all-libs"] : []),
-        ...sources.flat(),
+        ...sources,
         ...globalMocArgs,
         ...(options.extraArgs ?? []),
     ];
@@ -52,24 +153,10 @@ export async function check(files, options = {}) {
         if (options.verbose) {
             console.log(chalk.blue("check"), chalk.gray("Attempting to fix files"));
         }
-        const fixResult = await autofixMotoko(mocPath, fileList, mocArgs);
-        if (fixResult) {
-            for (const [file, codes] of fixResult.fixedFiles) {
-                const unique = [...new Set(codes)].sort();
-                const n = codes.length;
-                const rel = path.relative(process.cwd(), file);
-                console.log(chalk.green(`Fixed ${rel} (${n} ${n === 1 ? "fix" : "fixes"}: ${unique.join(", ")})`));
-            }
-            const fileCount = fixResult.fixedFiles.size;
-            console.log(chalk.green(`\n✓ ${fixResult.totalFixCount} ${fixResult.totalFixCount === 1 ? "fix" : "fixes"} applied to ${fileCount} ${fileCount === 1 ? "file" : "files"}`));
-        }
-        else {
-            if (options.verbose) {
-                console.log(chalk.yellow("No fixes were needed"));
-            }
-        }
+        const fixResult = await autofixMotoko(mocPath, files, mocArgs);
+        logAutofixResult(fixResult, options.verbose);
     }
-    for (const file of fileList) {
+    for (const file of files) {
         try {
             const args = [file, ...mocArgs];
             if (options.verbose) {
@@ -89,42 +176,4 @@ export async function check(files, options = {}) {
             cliError(`Error while checking ${file}${err?.message ? `\n${err.message}` : ""}`);
         }
     }
-    const canisters = resolveCanisterConfigs(config);
-    for (const [name, canister] of Object.entries(canisters)) {
-        const stableConfig = canister["check-stable"];
-        if (!stableConfig) {
-            continue;
-        }
-        if (!canister.main) {
-            cliError(`No main file specified for canister '${name}' in mops.toml`);
-        }
-        const stablePath = resolveConfigPath(stableConfig.path);
-        if (!existsSync(stablePath)) {
-            if (stableConfig.skipIfMissing) {
-                continue;
-            }
-            cliError(`Deployed file not found: ${stablePath} (canister '${name}')\n` +
-                "Set skipIfMissing = true in [canisters." +
-                name +
-                ".check-stable] to skip this check when the file is missing.");
-        }
-        await runStableCheck({
-            oldFile: stablePath,
-            canisterMain: resolveConfigPath(canister.main),
-            canisterName: name,
-            mocPath,
-            globalMocArgs,
-            options: { verbose: options.verbose, extraArgs: options.extraArgs },
-        });
-    }
-    if (config.toolchain?.lintoko) {
-        const rootDir = getRootDir();
-        const lintRules = await collectLintRules(config, rootDir);
-        await lint(undefined, {
-            verbose: options.verbose,
-            fix: options.fix,
-            rules: lintRules,
-            files: explicitFiles.length > 0 ? explicitFiles : undefined,
-        });
-    }
 }

package/dist/commands/info.d.ts

@@ -0,0 +1,4 @@
+export interface InfoOptions {
+    versions?: boolean;
+}
+export declare function info(pkgArg: string, options?: InfoOptions): Promise<void>;

package/dist/commands/info.js

@@ -0,0 +1,75 @@
+import process from "node:process";
+import chalk from "chalk";
+import { mainActor } from "../api/actors.js";
+import { resolveVersion } from "../api/resolveVersion.js";
+function label(text) {
+    return chalk.bold(text.padEnd(16));
+}
+export async function info(pkgArg, options = {}) {
+    let [name, versionArg] = pkgArg.split("@");
+    let actor = await mainActor();
+    let version;
+    try {
+        version = await resolveVersion(name, versionArg ?? "");
+    }
+    catch (err) {
+        let message = err instanceof Error ? err.message : String(err);
+        console.error(chalk.red("Error: ") + message);
+        process.exit(1);
+    }
+    let res = await actor.getPackageDetails(name, version);
+    if ("err" in res) {
+        console.error(chalk.red("Error: ") + res.err);
+        process.exit(1);
+    }
+    let d = res.ok;
+    let c = d.config;
+    // d.versions is in ascending order (oldest first)
+    if (options.versions) {
+        for (let ver of d.versions) {
+            console.log(ver);
+        }
+        return;
+    }
+    console.log("");
+    console.log(`${chalk.green.bold(c.name)}${chalk.gray("@")}${chalk.yellow(c.version)}`);
+    if (c.description) {
+        console.log(chalk.dim(c.description));
+    }
+    if (c.version !== d.highestVersion) {
+        console.log(chalk.yellow(`latest: ${d.highestVersion}`));
+    }
+    console.log("");
+    if (c.license) {
+        console.log(`${label("license")}${c.license}`);
+    }
+    if (c.repository) {
+        console.log(`${label("repository")}${chalk.cyan(c.repository)}`);
+    }
+    if (c.homepage) {
+        console.log(`${label("homepage")}${chalk.cyan(c.homepage)}`);
+    }
+    if (c.documentation) {
+        console.log(`${label("documentation")}${chalk.cyan(c.documentation)}`);
+    }
+    if (c.dependencies.length > 0) {
+        console.log("");
+        console.log(`${label("dependencies")}${c.dependencies.map((dep) => `${dep.name}${chalk.gray("@")}${dep.version || dep.repo}`).join(", ")}`);
+    }
+    if (c.devDependencies.length > 0) {
+        console.log(`${label("dev-deps")}${c.devDependencies.map((dep) => `${dep.name}${chalk.gray("@")}${dep.version || dep.repo}`).join(", ")}`);
+    }
+    if (c.keywords.length > 0) {
+        console.log("");
+        console.log(`${label("keywords")}${c.keywords.map((k) => chalk.yellow(k)).join(", ")}`);
+    }
+    if (d.versions.length > 0) {
+        let versionsDisplay = d.versions.slice(-10).reverse().join(", ");
+        let extra = d.versions.length > 10
+            ? ` ${chalk.gray(`(+${d.versions.length - 10} more)`)}`
+            : "";
+        console.log("");
+        console.log(`${label("versions")}${versionsDisplay}${extra}`);
+    }
+    console.log("");
+}

package/dist/commands/lint.js

@@ -64,6 +64,43 @@ export async function collectLintRules(config, rootDir) {
     const depRules = await resolveDepRules(config, rootDir);
     return [...localRules, ...depRules];
 }
+function buildCommonArgs(options, config) {
+    const args = [];
+    if (options.verbose) {
+        args.push("--verbose");
+    }
+    if (options.fix) {
+        args.push("--fix");
+    }
+    if (config.lint?.args) {
+        if (typeof config.lint.args === "string") {
+            cliError(`[lint] config 'args' should be an array of strings in mops.toml config file`);
+        }
+        args.push(...config.lint.args);
+    }
+    if (options.extraArgs && options.extraArgs.length > 0) {
+        args.push(...options.extraArgs);
+    }
+    return args;
+}
+async function runLintoko(lintokoBinPath, rootDir, args, options, label) {
+    try {
+        if (options.verbose) {
+            console.log(chalk.blue("lint"), chalk.gray(`Running lintoko (${label}):`));
+            console.log(chalk.gray(lintokoBinPath));
+            console.log(chalk.gray(JSON.stringify(args)));
+        }
+        const result = await execa(lintokoBinPath, args, {
+            cwd: rootDir,
+            stdio: "inherit",
+            reject: false,
+        });
+        return result.exitCode === 0;
+    }
+    catch (err) {
+        cliError(`Error while running lintoko${err?.message ? `\n${err.message}` : ""}`);
+    }
+}
 export async function lint(filter, options) {
     let config = readConfig();
     let rootDir = getRootDir();
@@ -86,49 +123,59 @@ export async function lint(filter, options) {
                 : "No .mo files found in the project");
         }
     }
-    let args = [];
-    if (options.verbose) {
-        args.push("--verbose");
-    }
-    if (options.fix) {
-        args.push("--fix");
-    }
+    const commonArgs = buildCommonArgs(options, config);
+    // --- base run ---
+    const baseArgs = [...commonArgs];
     const rules = options.rules !== undefined
         ? options.rules
         : await collectLintRules(config, rootDir);
-    rules.forEach((rule) => args.push("--rules", rule));
-    if (config.lint?.args) {
-        if (typeof config.lint.args === "string") {
-            cliError(`[lint] config 'args' should be an array of strings in mops.toml config file`);
+    rules.forEach((rule) => baseArgs.push("--rules", rule));
+    baseArgs.push(...filesToLint);
+    let failed = !(await runLintoko(lintokoBinPath, rootDir, baseArgs, options, "base"));
+    // --- extra runs ---
+    const extraEntries = config.lint?.extra;
+    if (extraEntries) {
+        const isFiltered = filter || (options.files && options.files.length > 0);
+        const baseFileSet = isFiltered
+            ? new Set(filesToLint.map((f) => path.resolve(rootDir, f)))
+            : undefined;
+        for (const [globPattern, ruleDirs] of Object.entries(extraEntries)) {
+            if (!Array.isArray(ruleDirs) || ruleDirs.length === 0) {
+                console.warn(chalk.yellow(`[lint.extra] skipping '${globPattern}': value must be a non-empty array of rule directories`));
+                continue;
+            }
+            for (const dir of ruleDirs) {
+                if (!existsSync(path.join(rootDir, dir))) {
+                    cliError(`[lint.extra] rule directory '${dir}' not found (referenced by glob '${globPattern}')`);
+                }
+            }
+            let matchedFiles = globSync(path.join(rootDir, globPattern), {
+                ...MOTOKO_GLOB_CONFIG,
+                cwd: rootDir,
+            });
+            if (baseFileSet) {
+                matchedFiles = matchedFiles.filter((f) => baseFileSet.has(path.resolve(rootDir, f)));
+            }
+            if (matchedFiles.length === 0) {
+                console.warn(chalk.yellow(`[lint.extra] no files matched glob '${globPattern}', skipping`));
+                continue;
+            }
+            const extraArgs = [...commonArgs];
+            for (const dir of ruleDirs) {
+                extraArgs.push("--rules", dir);
+            }
+            extraArgs.push(...matchedFiles);
+            const passed = await runLintoko(lintokoBinPath, rootDir, extraArgs, options, `extra: ${globPattern}`);
+            failed ||= !passed;
         }
-        args.push(...config.lint.args);
     }
-    if (options.extraArgs && options.extraArgs.length > 0) {
-        args.push(...options.extraArgs);
+    if (failed) {
+        cliError("Lint failed");
     }
-    args.push(...filesToLint);
-    try {
-        if (options.verbose) {
-            console.log(chalk.blue("lint"), chalk.gray("Running lintoko:"));
-            console.log(chalk.gray(lintokoBinPath));
-            console.log(chalk.gray(JSON.stringify(args)));
-        }
-        const result = await execa(lintokoBinPath, args, {
-            cwd: rootDir,
-            stdio: "inherit",
-            reject: false,
-        });
-        if (result.exitCode !== 0) {
-            cliError(`Lint failed with exit code ${result.exitCode}`);
-        }
-        if (options.fix) {
-            console.log(chalk.green("✓ Lint fixes applied"));
-        }
-        else {
-            console.log(chalk.green("✓ Lint succeeded"));
-        }
+    else if (options.fix) {
+        console.log(chalk.green("✓ Lint fixes applied"));
     }
-    catch (err) {
-        cliError(`Error while running lintoko${err?.message ? `\n${err.message}` : ""}`);
+    else {
+        console.log(chalk.green("✓ Lint succeeded"));
     }
 }

package/dist/commands/toolchain/moc.js

@@ -5,7 +5,7 @@ import { SemVer } from "semver";
 import { globalCacheDir } from "../../mops.js";
 import * as toolchainUtils from "./toolchain-utils.js";
 let cacheDir = path.join(globalCacheDir, "moc");
-export let repo = "dfinity/motoko";
+export let repo = "caffeinelabs/motoko";
 export let getLatestReleaseTag = async () => {
     return toolchainUtils.getLatestReleaseTag(repo);
 };
@@ -33,7 +33,7 @@ export let download = async (version, { silent = false, verbose = false } = {})
     }
     else {
         // Download the .js artifact
-        const jsUrl = `https://github.com/dfinity/motoko/releases/download/${version}/moc-${version}.js`;
+        const jsUrl = `https://github.com/caffeinelabs/motoko/releases/download/${version}/moc-${version}.js`;
         const jsDestPath = path.join(destDir, "moc.js");
         if (verbose && !silent) {
             console.log(`Downloading ${jsUrl}`);
@@ -61,16 +61,16 @@ export let download = async (version, { silent = false, verbose = false } = {})
                 ? "arm64"
                 : "aarch64"
             : "x86_64";
-        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+        url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
     }
     else if (new SemVer(version).compare(new SemVer("0.9.5")) >= 0) {
         let platfrom = process.platform == "darwin" ? "Darwin" : "Linux";
         let arch = "x86_64";
-        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
+        url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${arch}-${version}.tar.gz`;
     }
     else {
         let platfrom = process.platform == "darwin" ? "macos" : "linux64";
-        url = `https://github.com/dfinity/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
+        url = `https://github.com/caffeinelabs/motoko/releases/download/${version}/motoko-${platfrom}-${version}.tar.gz`;
     }
     if (verbose && !silent) {
         console.log(`Downloading ${url}`);

package/dist/helpers/resolve-canisters.d.ts

@@ -1,7 +1,9 @@
 import { CanisterConfig, Config } from "../types.js";
 export declare function resolveCanisterConfigs(config: Config): Record<string, CanisterConfig>;
-export declare function resolveCanisterEntrypoints(config: Config): string[];
+export declare function filterCanisters(canisters: Record<string, CanisterConfig>, names?: string[]): Record<string, CanisterConfig>;
 export declare function resolveSingleCanister(config: Config, canisterName?: string): {
     name: string;
     canister: CanisterConfig;
 };
+export declare function looksLikeFile(arg: string): boolean;
+export declare function validateCanisterArgs(canister: CanisterConfig, canisterName: string): void;

package/dist/helpers/resolve-canisters.js

@@ -5,11 +5,15 @@ export function resolveCanisterConfigs(config) {
     }
     return Object.fromEntries(Object.entries(config.canisters).map(([name, c]) => typeof c === "string" ? [name, { main: c }] : [name, c]));
 }
-export function resolveCanisterEntrypoints(config) {
-    const canisters = resolveCanisterConfigs(config);
-    return Object.values(canisters)
-        .map((c) => c.main)
-        .filter((main) => Boolean(main));
+export function filterCanisters(canisters, names) {
+    if (!names) {
+        return canisters;
+    }
+    const invalidNames = names.filter((name) => !(name in canisters));
+    if (invalidNames.length) {
+        cliError(`Canister(s) not found in mops.toml: ${invalidNames.join(", ")}. Available: ${Object.keys(canisters).join(", ")}`);
+    }
+    return Object.fromEntries(Object.entries(canisters).filter(([name]) => names.includes(name)));
 }
 export function resolveSingleCanister(config, canisterName) {
     const canisters = resolveCanisterConfigs(config);
@@ -29,3 +33,14 @@ export function resolveSingleCanister(config, canisterName) {
     }
     return { name: names[0], canister: canisters[names[0]] };
 }
+export function looksLikeFile(arg) {
+    return (arg.endsWith(".mo") ||
+        arg.endsWith(".most") ||
+        arg.includes("/") ||
+        arg.includes("\\"));
+}
+export function validateCanisterArgs(canister, canisterName) {
+    if (canister.args && typeof canister.args === "string") {
+        cliError(`Canister config 'args' should be an array of strings for canister ${canisterName}`);
+    }
+}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ic-mops",
-  "version": "2.8.1",
+  "version": "2.10.0",
   "type": "module",
   "bin": {
     "mops": "bin/mops.js",
@@ -65,6 +65,7 @@
     "prettier-plugin-motoko": "0.13.0",
     "promisify-child-process": "4.1.2",
     "prompts": "2.4.2",
+    "proper-lockfile": "4.1.2",
     "semver": "7.7.1",
     "stream-to-promise": "3.0.0",
     "string-width": "7.2.0",
@@ -81,6 +82,7 @@
     "@types/ncp": "2.0.8",
     "@types/node": "24.0.3",
     "@types/prompts": "2.4.9",
+    "@types/proper-lockfile": "4.1.4",
     "@types/semver": "7.5.8",
     "@types/stream-to-promise": "2.2.4",
     "@types/tar": "6.1.13",

package/dist/templates/mops-publish.yml

@@ -10,7 +10,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-      - uses: dfinity/setup-mops@v1
+      - uses: caffeinelabs/setup-mops@v1
         with:
           # Make sure you set the MOPS_IDENTITY_PEM secret in your repository settings https://docs.github.com/en/actions/security-guides/using-secrets-in-github-actions#creating-secrets-for-a-repository
           identity-pem: ${{ secrets.MOPS_IDENTITY_PEM }}

package/dist/templates/mops-test.yml

@@ -13,7 +13,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-      - uses: dfinity/setup-mops@v1
+      - uses: caffeinelabs/setup-mops@v1
         with:
           mops-version: 1
 

package/dist/tests/build.test.js

@@ -85,6 +85,23 @@ describe("build", () => {
             cleanFixture(cwd, artifact, artifactDid);
         }
     });
+    test("parallel builds of the same canister both succeed", async () => {
+        const cwd = path.join(import.meta.dirname, "build/success");
+        try {
+            const [a, b] = await Promise.all([
+                cli(["build", "foo"], { cwd }),
+                cli(["build", "foo"], { cwd }),
+            ]);
+            expect(a.exitCode).toBe(0);
+            expect(b.exitCode).toBe(0);
+            expect(existsSync(path.join(cwd, ".mops/.build/foo.wasm"))).toBe(true);
+            expect(existsSync(path.join(cwd, ".mops/.build/foo.did"))).toBe(true);
+            expect(existsSync(path.join(cwd, ".mops/.build/foo.most"))).toBe(true);
+        }
+        finally {
+            cleanFixture(cwd);
+        }
+    });
     // Regression: bin/mops.js must route through environments/nodejs/cli.js
     // so that setWasmBindings() is called before any command runs.
     // The dev entry point (npm run mops) uses tsx and always worked;

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

@@ -53,6 +53,24 @@ describe("check-stable", () => {
         expect(existsSync(path.join(cwd, "new.most"))).toBe(false);
         expect(existsSync(path.join(cwd, "new.wasm"))).toBe(false);
     });
+    test("[canisters.X].args are passed to moc (enhanced migration)", async () => {
+        const cwd = path.join(import.meta.dirname, "check-stable/canister-args");
+        const result = await cli(["check-stable", "old.most"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    });
+    test("no args checks all canisters with [check-stable] config", async () => {
+        const cwd = path.join(import.meta.dirname, "check/deployed-compatible");
+        const result = await cli(["check-stable"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    });
+    test("canister name filters to specific canister", async () => {
+        const cwd = path.join(import.meta.dirname, "check/deployed-compatible");
+        const result = await cli(["check-stable", "backend"], { cwd });
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toMatch(/Stable compatibility check passed/);
+    });
     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 });