ic-mops 2.8.1 → 2.10.0

package/dist/cli.js

@@ -15,6 +15,7 @@ import { checkStable } from "./commands/check-stable.js";
 import { docsCoverage } from "./commands/docs-coverage.js";
 import { docs } from "./commands/docs.js";
 import { format } from "./commands/format.js";
+import { info } from "./commands/info.js";
 import { init } from "./commands/init.js";
 import { lint } from "./commands/lint.js";
 import { installAll } from "./commands/install/install-all.js";
@@ -213,6 +214,14 @@ program
     .action(async (text) => {
     await search(text);
 });
+// info
+program
+    .command("info <pkg>")
+    .description("Show detailed information about a package from the registry")
+    .option("--versions", "List all published versions, one per line")
+    .action(async (pkg, options) => {
+    await info(pkg, options);
+});
 // cache
 program
     .command("cache")
@@ -254,20 +263,20 @@ program
 });
 // check
 program
-    .command("check [files...]")
-    .description("Check Motoko files for syntax errors and type issues. If no files are specified, checks all canister entrypoints from mops.toml. Also runs stable compatibility checks for canisters with [check-stable] configured, and runs linting if lintoko is configured in [toolchain] and rule directories are present")
+    .command("check [args...]")
+    .description("Check Motoko canisters or files for syntax errors and type issues. Arguments can be canister names or file paths. If no arguments are given, checks all canisters from mops.toml. Also runs stable compatibility checks for canisters with [check-stable] configured, and runs linting if lintoko is configured in [toolchain]")
     .option("--verbose", "Verbose console output")
     .addOption(new Option("--fix", "Apply autofixes to all files, including transitively imported ones"))
     .allowUnknownOption(true)
-    .action(async (files, options) => {
+    .action(async (args, options) => {
     checkConfigFile(true);
-    const { extraArgs, args: fileList } = parseExtraArgs(files);
+    const { extraArgs, args: argList } = parseExtraArgs(args);
     await installAll({
         silent: true,
         lock: "ignore",
         installFromLockFile: true,
     });
-    await check(fileList, {
+    await check(argList, {
         ...options,
         extraArgs,
     });
@@ -287,19 +296,19 @@ program
 });
 // check-stable
 program
-    .command("check-stable <old-file> [canister]")
-    .description("Check stable variable compatibility between an old version (.mo or .most file) and the current canister entrypoint")
+    .command("check-stable [args...]")
+    .description("Check stable variable compatibility. With no arguments, checks all canisters with [check-stable] configured. Arguments can be canister names or an old file path followed by an optional canister name")
     .option("--verbose", "Verbose console output")
     .allowUnknownOption(true)
-    .action(async (oldFile, canister, options) => {
+    .action(async (args, options) => {
     checkConfigFile(true);
-    const { extraArgs } = parseExtraArgs();
+    const { extraArgs, args: argList } = parseExtraArgs(args);
     await installAll({
         silent: true,
         lock: "ignore",
         installFromLockFile: true,
     });
-    await checkStable(oldFile, canister, {
+    await checkStable(argList, {
         ...options,
         extraArgs,
     });

package/dist/commands/build.js

@@ -3,9 +3,10 @@ import { execa } from "execa";
 import { exists } from "fs-extra";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { lock, unlockSync } from "proper-lockfile";
 import { cliError } from "../error.js";
 import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
-import { resolveCanisterConfigs } from "../helpers/resolve-canisters.js";
+import { filterCanisters, resolveCanisterConfigs, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
 import { getWasmBindings } from "../wasm.js";
 import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
 import { sourcesArgs } from "./sources.js";
@@ -25,18 +26,10 @@ export async function build(canisterNames, options) {
     if (!Object.keys(canisters).length) {
         cliError(`No Motoko canisters found in mops.toml configuration`);
     }
-    if (canisterNames) {
-        let invalidNames = canisterNames.filter((name) => !(name in canisters));
-        if (invalidNames.length) {
-            cliError(`Motoko canister(s) not found in mops.toml configuration: ${invalidNames.join(", ")}`);
-        }
-    }
     if (!(await exists(outputDir))) {
         await mkdir(outputDir, { recursive: true });
     }
-    const filteredCanisters = canisterNames
-        ? Object.fromEntries(Object.entries(canisters).filter(([name]) => canisterNames.includes(name)))
-        : canisters;
+    const filteredCanisters = filterCanisters(canisters, canisterNames);
     for (let [canisterName, canister] of Object.entries(filteredCanisters)) {
         console.log(chalk.blue("build canister"), chalk.bold(canisterName));
         let motokoPath = canister.main;
@@ -46,88 +39,120 @@ 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,
-            ...(await sourcesArgs()).flat(),
-            ...getGlobalMocArgs(config),
-        ];
-        args.push(...collectExtraArgs(config, canister, canisterName, options.extraArgs));
-        const isPublicCandid = true; // always true for now to reduce corner cases
-        const candidVisibility = isPublicCandid ? "icp:public" : "icp:private";
-        if (isPublicCandid) {
-            args.push("--public-metadata", "candid:service");
-            args.push("--public-metadata", "candid:args");
+        // per-canister lock to prevent parallel builds of the same canister from clobbering output files
+        const lockTarget = join(outputDir, `.${canisterName}.buildlock`);
+        await writeFile(lockTarget, "", { flag: "a" });
+        let release;
+        try {
+            release = await lock(lockTarget, {
+                stale: 300_000,
+                retries: { retries: 60, minTimeout: 500, maxTimeout: 5_000 },
+            });
+        }
+        catch {
+            cliError(`Failed to acquire build lock for canister ${canisterName} — another build may be stuck`);
         }
+        // proper-lockfile registers its own signal-exit handler, but it doesn't reliably
+        // fire on process.exit(). This manual handler covers that gap. Double-unlock is
+        // harmless (the second call throws and is caught).
+        const exitCleanup = () => {
+            try {
+                unlockSync(lockTarget);
+            }
+            catch { }
+        };
+        process.on("exit", exitCleanup);
         try {
-            if (options.verbose) {
-                console.log(chalk.gray(mocPath, JSON.stringify(args)));
+            let args = [
+                "-c",
+                "--idl",
+                "--stable-types",
+                "-o",
+                wasmPath,
+                motokoPath,
+                ...(await sourcesArgs()).flat(),
+                ...getGlobalMocArgs(config),
+            ];
+            args.push(...collectExtraArgs(config, canister, canisterName, options.extraArgs));
+            const isPublicCandid = true; // always true for now to reduce corner cases
+            const candidVisibility = isPublicCandid ? "icp:public" : "icp:private";
+            if (isPublicCandid) {
+                args.push("--public-metadata", "candid:service");
+                args.push("--public-metadata", "candid:args");
             }
-            const result = await execa(mocPath, args, {
-                stdio: options.verbose ? "inherit" : "pipe",
-                reject: false,
-            });
-            if (result.exitCode !== 0) {
-                if (!options.verbose) {
-                    if (result.stderr) {
-                        console.error(chalk.red(result.stderr));
-                    }
-                    if (result.stdout?.trim()) {
-                        console.error(chalk.yellow("Build output:"));
-                        console.error(result.stdout);
+            try {
+                if (options.verbose) {
+                    console.log(chalk.gray(mocPath, JSON.stringify(args)));
+                }
+                const result = await execa(mocPath, args, {
+                    stdio: options.verbose ? "inherit" : "pipe",
+                    reject: false,
+                });
+                if (result.exitCode !== 0) {
+                    if (!options.verbose) {
+                        if (result.stderr) {
+                            console.error(chalk.red(result.stderr));
+                        }
+                        if (result.stdout?.trim()) {
+                            console.error(chalk.yellow("Build output:"));
+                            console.error(result.stdout);
+                        }
                     }
+                    cliError(`Build failed for canister ${canisterName} (exit code: ${result.exitCode})`);
                 }
-                cliError(`Build failed for canister ${canisterName} (exit code: ${result.exitCode})`);
-            }
-            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)
-                : null;
-            if (resolvedCandidPath) {
-                try {
-                    const compatible = await isCandidCompatible(generatedDidPath, resolvedCandidPath);
-                    if (!compatible) {
-                        cliError(`Candid compatibility check failed for canister ${canisterName}`);
+                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)
+                    : null;
+                if (resolvedCandidPath) {
+                    try {
+                        const compatible = await isCandidCompatible(generatedDidPath, resolvedCandidPath);
+                        if (!compatible) {
+                            cliError(`Candid compatibility check failed for canister ${canisterName}`);
+                        }
+                        if (options.verbose) {
+                            console.log(chalk.gray(`Candid compatibility check passed for canister ${canisterName}`));
+                        }
                     }
-                    if (options.verbose) {
-                        console.log(chalk.gray(`Candid compatibility check passed for canister ${canisterName}`));
+                    catch (err) {
+                        cliError(`Error during Candid compatibility check for canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
                     }
                 }
-                catch (err) {
-                    cliError(`Error during Candid compatibility check for canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
+                options.verbose &&
+                    console.log(chalk.gray(`Adding metadata to ${wasmPath}`));
+                const candidPath = resolvedCandidPath ?? generatedDidPath;
+                const candidText = await readFile(candidPath, "utf-8");
+                const customSections = [
+                    { name: `${candidVisibility} candid:service`, data: candidText },
+                ];
+                if (canister.initArg) {
+                    customSections.push({
+                        name: `${candidVisibility} candid:args`,
+                        data: canister.initArg,
+                    });
                 }
+                const wasmBytes = await readFile(wasmPath);
+                const newWasm = getWasmBindings().add_custom_sections(wasmBytes, customSections);
+                await writeFile(wasmPath, newWasm);
             }
-            options.verbose &&
-                console.log(chalk.gray(`Adding metadata to ${wasmPath}`));
-            const candidPath = resolvedCandidPath ?? generatedDidPath;
-            const candidText = await readFile(candidPath, "utf-8");
-            const customSections = [
-                { name: `${candidVisibility} candid:service`, data: candidText },
-            ];
-            if (canister.initArg) {
-                customSections.push({
-                    name: `${candidVisibility} candid:args`,
-                    data: canister.initArg,
-                });
+            catch (err) {
+                if (err.message?.includes("Build failed for canister")) {
+                    throw err;
+                }
+                cliError(`Error while compiling canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
             }
-            const wasmBytes = await readFile(wasmPath);
-            const newWasm = getWasmBindings().add_custom_sections(wasmBytes, customSections);
-            await writeFile(wasmPath, newWasm);
         }
-        catch (err) {
-            if (err.message?.includes("Build failed for canister")) {
-                throw err;
+        finally {
+            process.removeListener("exit", exitCleanup);
+            try {
+                await release?.();
             }
-            cliError(`Error while compiling canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`);
+            catch { }
         }
     }
     console.log(chalk.green(`\n✓ Built ${Object.keys(filteredCanisters).length} canister${Object.keys(filteredCanisters).length === 1 ? "" : "s"} successfully`));
@@ -148,9 +173,7 @@ function collectExtraArgs(config, canister, canisterName, extraArgs) {
         args.push(...config.build.args);
     }
     if (canister.args) {
-        if (typeof canister.args === "string") {
-            cliError(`Canister config 'args' should be an array of strings for canister ${canisterName}`);
-        }
+        validateCanisterArgs(canister, canisterName);
         args.push(...canister.args);
     }
     if (extraArgs) {

package/dist/commands/check-stable.d.ts

@@ -1,14 +1,20 @@
+import { CanisterConfig } from "../types.js";
 export interface CheckStableOptions {
     verbose: boolean;
     extraArgs: string[];
 }
-export declare function checkStable(oldFile: string, canisterName: string | undefined, options?: Partial<CheckStableOptions>): Promise<void>;
+export declare function resolveStablePath(canister: CanisterConfig, canisterName: string, options?: {
+    required?: boolean;
+}): string | null;
+export declare function checkStable(args: string[], options?: Partial<CheckStableOptions>): Promise<void>;
 export interface RunStableCheckParams {
     oldFile: string;
     canisterMain: string;
     canisterName: string;
     mocPath: string;
     globalMocArgs: string[];
+    canisterArgs: string[];
+    sources?: string[];
     options?: Partial<CheckStableOptions>;
 }
 export declare function runStableCheck(params: RunStableCheckParams): Promise<void>;

package/dist/commands/check-stable.js

@@ -5,30 +5,93 @@ import chalk from "chalk";
 import { execa } from "execa";
 import { cliError } from "../error.js";
 import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
-import { resolveSingleCanister } from "../helpers/resolve-canisters.js";
+import { filterCanisters, looksLikeFile, resolveCanisterConfigs, resolveSingleCanister, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
 import { sourcesArgs } from "./sources.js";
 import { toolchain } from "./toolchain/index.js";
 const CHECK_STABLE_DIR = ".mops/.check-stable";
-export async function checkStable(oldFile, canisterName, options = {}) {
-    const config = readConfig();
-    const { name, canister } = resolveSingleCanister(config, canisterName);
-    if (!canister.main) {
-        cliError(`No main file specified for canister '${name}' in mops.toml`);
+export function resolveStablePath(canister, canisterName, options) {
+    const stableConfig = canister["check-stable"];
+    if (!stableConfig) {
+        if (options?.required) {
+            cliError(`Canister '${canisterName}' has no [canisters.${canisterName}.check-stable] configuration in mops.toml`);
+        }
+        return null;
     }
+    const stablePath = resolveConfigPath(stableConfig.path);
+    if (!existsSync(stablePath)) {
+        if (stableConfig.skipIfMissing) {
+            return null;
+        }
+        cliError(`Deployed file not found: ${stablePath} (canister '${canisterName}')\n` +
+            "Set skipIfMissing = true in [canisters." +
+            canisterName +
+            ".check-stable] to skip this check when the file is missing.");
+    }
+    return stablePath;
+}
+export async function checkStable(args, options = {}) {
+    const config = readConfig();
     const mocPath = await toolchain.bin("moc", { fallback: true });
     const globalMocArgs = getGlobalMocArgs(config);
-    await runStableCheck({
-        oldFile,
-        canisterMain: resolveConfigPath(canister.main),
-        canisterName: name,
-        mocPath,
-        globalMocArgs,
-        options,
-    });
+    const firstArg = args[0];
+    if (firstArg && looksLikeFile(firstArg)) {
+        const oldFile = firstArg;
+        const canisterName = args[1];
+        const { name, canister } = resolveSingleCanister(config, canisterName);
+        if (!canister.main) {
+            cliError(`No main file specified for canister '${name}' in mops.toml`);
+        }
+        validateCanisterArgs(canister, name);
+        await runStableCheck({
+            oldFile,
+            canisterMain: resolveConfigPath(canister.main),
+            canisterName: name,
+            mocPath,
+            globalMocArgs,
+            canisterArgs: canister.args ?? [],
+            options,
+        });
+        return;
+    }
+    const canisters = resolveCanisterConfigs(config);
+    const canisterNames = args.length > 0 ? args : undefined;
+    const filteredCanisters = filterCanisters(canisters, canisterNames);
+    const sources = (await sourcesArgs()).flat();
+    let checked = 0;
+    for (const [name, canister] of Object.entries(filteredCanisters)) {
+        if (!canister.main) {
+            cliError(`No main file specified for canister '${name}' in mops.toml`);
+        }
+        validateCanisterArgs(canister, name);
+        const stablePath = resolveStablePath(canister, name, {
+            required: !!canisterNames,
+        });
+        if (!stablePath) {
+            continue;
+        }
+        await runStableCheck({
+            oldFile: stablePath,
+            canisterMain: resolveConfigPath(canister.main),
+            canisterName: name,
+            mocPath,
+            globalMocArgs,
+            canisterArgs: canister.args ?? [],
+            sources,
+            options,
+        });
+        checked++;
+    }
+    if (checked === 0 && !canisterNames) {
+        cliError("No canisters with [check-stable] configuration found in mops.toml.\n" +
+            "Either pass an old file: mops check-stable <old-file> [canister]\n" +
+            "Or configure check-stable for a canister:\n\n" +
+            "  [canisters.backend.check-stable]\n" +
+            '  path = "deployed.mo"');
+    }
 }
 export async function runStableCheck(params) {
-    const { oldFile, canisterMain, canisterName, mocPath, globalMocArgs, options = {}, } = params;
-    const sources = (await sourcesArgs()).flat();
+    const { oldFile, canisterMain, canisterName, mocPath, globalMocArgs, canisterArgs, options = {}, } = params;
+    const sources = params.sources ?? (await sourcesArgs()).flat();
     const isOldMostFile = oldFile.endsWith(".most");
     if (!existsSync(oldFile)) {
         cliError(`File not found: ${oldFile}`);
@@ -38,8 +101,8 @@ export async function runStableCheck(params) {
     try {
         const oldMostPath = isOldMostFile
             ? oldFile
-            : await generateStableTypes(mocPath, oldFile, join(CHECK_STABLE_DIR, "old.most"), sources, globalMocArgs, options);
-        const newMostPath = await generateStableTypes(mocPath, canisterMain, join(CHECK_STABLE_DIR, "new.most"), sources, globalMocArgs, options);
+            : await generateStableTypes(mocPath, oldFile, join(CHECK_STABLE_DIR, "old.most"), sources, globalMocArgs, canisterArgs, options);
+        const newMostPath = await generateStableTypes(mocPath, canisterMain, join(CHECK_STABLE_DIR, "new.most"), sources, globalMocArgs, canisterArgs, options);
         if (options.verbose) {
             console.log(chalk.blue("check-stable"), chalk.gray(`Comparing ${oldMostPath} ↔ ${newMostPath}`));
         }
@@ -63,7 +126,7 @@ export async function runStableCheck(params) {
         await rm(CHECK_STABLE_DIR, { recursive: true, force: true });
     }
 }
-async function generateStableTypes(mocPath, moFile, outputPath, sources, globalMocArgs, options) {
+async function generateStableTypes(mocPath, moFile, outputPath, sources, globalMocArgs, canisterArgs, options) {
     const base = basename(outputPath, ".most");
     const wasmPath = join(CHECK_STABLE_DIR, base + ".wasm");
     const args = [
@@ -73,6 +136,7 @@ async function generateStableTypes(mocPath, moFile, outputPath, sources, globalM
         moFile,
         ...sources,
         ...globalMocArgs,
+        ...canisterArgs,
         ...(options.extraArgs ?? []),
     ];
     if (options.verbose) {

package/dist/commands/check.d.ts

@@ -3,4 +3,4 @@ export interface CheckOptions {
     fix: boolean;
     extraArgs: string[];
 }
-export declare function check(files: string | string[], options?: Partial<CheckOptions>): Promise<void>;
+export declare function check(args: string[], options?: Partial<CheckOptions>): Promise<void>;