ic-mops 2.8.0 → 2.9.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Next
 
+## 2.9.0
+- Add `mops info <pkg>` command to show detailed package metadata from the registry
+- Add `[lint.extra]` config for applying additional lint rules to specific files via glob patterns
+
+## 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

package/cli.ts

@@ -8,7 +8,7 @@ import { getNetwork } from "./api/network.js";
 import { cacheSize, cleanCache, show } from "./cache.js";
 import { add } from "./commands/add.js";
 import { bench } from "./commands/bench.js";
-import { build, DEFAULT_BUILD_OUTPUT_DIR } from "./commands/build.js";
+import { build } from "./commands/build.js";
 import { bump } from "./commands/bump.js";
 import { check } from "./commands/check.js";
 import { checkCandid } from "./commands/check-candid.js";
@@ -16,6 +16,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";
@@ -279,6 +280,15 @@ program
     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: string, options) => {
+    await info(pkg, options);
+  });
+
 // cache
 program
   .command("cache")

package/commands/build.ts

@@ -3,6 +3,7 @@ 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";
@@ -70,115 +71,149 @@ 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,
-      ...(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: (() => Promise<void>) | undefined;
+    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,
-      });
+      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);
+        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}`));
+        if (options.verbose && result.stdout && result.stdout.trim()) {
+          console.log(result.stdout);
+        }
 
-      const generatedDidPath = join(outputDir, `${canisterName}.did`);
-      const resolvedCandidPath = canister.candid
-        ? resolveConfigPath(canister.candid)
-        : null;
+        options.verbose &&
+          console.log(chalk.gray(`Stable types written to ${mostPath}`));
 
-      if (resolvedCandidPath) {
-        try {
-          const compatible = await isCandidCompatible(
-            generatedDidPath,
-            resolvedCandidPath,
-          );
+        const generatedDidPath = join(outputDir, `${canisterName}.did`);
+        const resolvedCandidPath = canister.candid
+          ? resolveConfigPath(canister.candid)
+          : null;
 
-          if (!compatible) {
-            cliError(
-              `Candid compatibility check failed for canister ${canisterName}`,
+        if (resolvedCandidPath) {
+          try {
+            const compatible = await isCandidCompatible(
+              generatedDidPath,
+              resolvedCandidPath,
             );
-          }
 
-          if (options.verbose) {
-            console.log(
-              chalk.gray(
-                `Candid compatibility check passed for canister ${canisterName}`,
-              ),
+            if (!compatible) {
+              cliError(
+                `Candid compatibility check failed for canister ${canisterName}`,
+              );
+            }
+
+            if (options.verbose) {
+              console.log(
+                chalk.gray(
+                  `Candid compatibility check passed for canister ${canisterName}`,
+                ),
+              );
+            }
+          } catch (err: any) {
+            cliError(
+              `Error during Candid compatibility check for canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`,
             );
           }
-        } catch (err: any) {
-          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: CustomSection[] = [
-        { 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);
-    } catch (err: any) {
-      if (err.message?.includes("Build failed for canister")) {
-        throw err;
+        options.verbose &&
+          console.log(chalk.gray(`Adding metadata to ${wasmPath}`));
+        const candidPath = resolvedCandidPath ?? generatedDidPath;
+        const candidText = await readFile(candidPath, "utf-8");
+        const customSections: CustomSection[] = [
+          { 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);
+      } catch (err: any) {
+        if (err.message?.includes("Build failed for canister")) {
+          throw err;
+        }
+        cliError(
+          `Error while compiling canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`,
+        );
       }
-      cliError(
-        `Error while compiling canister ${canisterName}${err?.message ? `\n${err.message}` : ""}`,
-      );
+    } finally {
+      process.removeListener("exit", exitCleanup);
+      try {
+        await release?.();
+      } catch {}
     }
   }
 

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/commands/info.ts

@@ -0,0 +1,103 @@
+import process from "node:process";
+import chalk from "chalk";
+import { mainActor } from "../api/actors.js";
+import { resolveVersion } from "../api/resolveVersion.js";
+import type { PackageDetails } from "../declarations/main/main.did.js";
+
+function label(text: string): string {
+  return chalk.bold(text.padEnd(16));
+}
+
+export interface InfoOptions {
+  versions?: boolean;
+}
+
+export async function info(pkgArg: string, options: InfoOptions = {}) {
+  let [name, versionArg] = pkgArg.split("@") as [string, string | undefined];
+  let actor = await mainActor();
+
+  let version: string;
+  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: PackageDetails = 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/commands/lint.ts

@@ -103,6 +103,62 @@ export interface LintOptions {
   extraArgs: string[];
 }
 
+function buildCommonArgs(
+  options: Partial<LintOptions>,
+  config: Config,
+): string[] {
+  const args: string[] = [];
+  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: string,
+  rootDir: string,
+  args: string[],
+  options: Partial<LintOptions>,
+  label: string,
+): Promise<boolean> {
+  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: any) {
+    cliError(
+      `Error while running lintoko${err?.message ? `\n${err.message}` : ""}`,
+    );
+  }
+}
+
 export async function lint(
   filter: string | undefined,
   options: Partial<LintOptions>,
@@ -131,59 +187,93 @@ export async function lint(
     }
   }
 
-  let args: string[] = [];
-  if (options.verbose) {
-    args.push("--verbose");
-  }
-  if (options.fix) {
-    args.push("--fix");
-  }
+  const commonArgs = buildCommonArgs(options, config);
+
+  // --- base run ---
+  const baseArgs: string[] = [...commonArgs];
   const rules =
     options.rules !== undefined
       ? options.rules
       : await collectLintRules(config, rootDir);
-  rules.forEach((rule) => args.push("--rules", rule));
+  rules.forEach((rule) => baseArgs.push("--rules", rule));
+  baseArgs.push(...filesToLint);
 
-  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);
-  }
+  let failed = !(await runLintoko(
+    lintokoBinPath,
+    rootDir,
+    baseArgs,
+    options,
+    "base",
+  ));
 
-  if (options.extraArgs && options.extraArgs.length > 0) {
-    args.push(...options.extraArgs);
-  }
+  // --- 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;
 
-  args.push(...filesToLint);
+    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;
+      }
 
-  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)));
-    }
+      for (const dir of ruleDirs) {
+        if (!existsSync(path.join(rootDir, dir))) {
+          cliError(
+            `[lint.extra] rule directory '${dir}' not found (referenced by glob '${globPattern}')`,
+          );
+        }
+      }
 
-    const result = await execa(lintokoBinPath, args, {
-      cwd: rootDir,
-      stdio: "inherit",
-      reject: false,
-    });
+      let matchedFiles = globSync(path.join(rootDir, globPattern), {
+        ...MOTOKO_GLOB_CONFIG,
+        cwd: rootDir,
+      });
 
-    if (result.exitCode !== 0) {
-      cliError(`Lint failed with exit code ${result.exitCode}`);
-    }
+      if (baseFileSet) {
+        matchedFiles = matchedFiles.filter((f) =>
+          baseFileSet.has(path.resolve(rootDir, f)),
+        );
+      }
 
-    if (options.fix) {
-      console.log(chalk.green("✓ Lint fixes applied"));
-    } else {
-      console.log(chalk.green("✓ Lint succeeded"));
+      if (matchedFiles.length === 0) {
+        console.warn(
+          chalk.yellow(
+            `[lint.extra] no files matched glob '${globPattern}', skipping`,
+          ),
+        );
+        continue;
+      }
+
+      const extraArgs: string[] = [...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;
     }
-  } catch (err: any) {
-    cliError(
-      `Error while running lintoko${err?.message ? `\n${err.message}` : ""}`,
-    );
+  }
+
+  if (failed) {
+    cliError("Lint failed");
+  } else if (options.fix) {
+    console.log(chalk.green("✓ Lint fixes applied"));
+  } else {
+    console.log(chalk.green("✓ Lint succeeded"));
   }
 }