ic-mops 2.14.1 → 2.15.1

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## Next
 
+## 2.15.1
+
+- `mops check --fix` no longer aborts when a fixable file is read-only (e.g. a frozen migration chain file deliberately `chmod`'d to remove write access). The autofixer now skips such files with a warning and continues fixing the rest, instead of crashing the whole run on `EACCES`/`EPERM`.
+
+- Load the PocketIC client lazily, only when a command actually starts a replica. Commands like `mops check`, `mops build`, and `mops install` no longer pay to load it (and its `@icp-sdk/core` dependency) at startup. This also unblocks running the CLI via `tsx` in local dev, where `pic-js-mops` (shipped as ESM without `"type": "module"`) fails to resolve as a static import.
+
+- `mops bench --verbose` is now actually verbose. It prints the benchmark pipeline up front — compiler version, replica + version, GC, profile, and whether the wasm is optimized (`dfx` post-optimizes with `optimize: "cycles"` via ic-wasm on deploy; `pocket-ic` runs the raw `moc` output) — logs the full `moc` build command, and streams the compiler and `dfx` output instead of capturing and discarding it. Notably this surfaces dfx's `WARNING: Failed to optimize the Wasm module`, which dfx prints (and then silently deploys the unoptimized module) when `optimize: "cycles"` fails — e.g. on multi-value modules that the bundled ic-wasm can't process. Previously all of this was hidden even with `--verbose`.
+
+## 2.15.0
+
+- Fix `mops check --fix` corrupting source on lines containing multi-byte UTF-8 characters (e.g. `Char.toNat32('京')` dropping its trailing `)`). The autofixer was feeding moc's UTF-8 byte columns into LSP's UTF-16 position API, mis-applying every edit past the first non-ASCII byte on the line. When moc emits `byte_start`/`byte_end` (1.10.0 and newer) the fixer now applies edits byte-accurately; older moc still falls back to the line+column path (unchanged behavior, still ASCII-only).
+
+- Revert "Speed up `mops check <files...>`" (2.14.1). Passing all files to a single `moc --check` invocation accumulates scope across them: checking `A.mo B.mo` makes `A.mo`'s definitions visible while type-checking `B.mo`, so a file that only compiles because a sibling brings something into scope is wrongly reported as passing. `mops check` again checks each file in its own `moc` invocation so every file is validated in isolation.
+
+- Add `--no-check-limit` to `mops check`, `mops check-stable`, and `mops lint` to process the full migration chain for a single run, ignoring the configured `[canisters.<name>.migrations].check-limit`. Handy for `mops check --fix --no-check-limit` to autofix issues in older migrations that the limit normally skips
+
+- `--help` now lists every option and the `-- <tool flags>` passthrough for each command: `mops build`, `mops check`, `mops check-stable`, and `mops generate candid` document `-- <moc flags>` (e.g. `mops check -- -Werror`), `mops lint` documents `-- <lintoko flags>`, and the `--verbose` flag of `mops add`/`mops install`/`mops publish` now has a description instead of showing blank
+
+- Add `mops deployed` (post-deploy hook) and `mops deployed init` (one-time bootstrap). After a successful deploy, `mops deployed [canisters...]` promotes the built `<build-dir>/<name>.most` into `<deployed-dir>/<name>.most` so `mops check-stable` always compares against the just-deployed version. `mops deployed init` creates an empty-actor `.most` baseline and wires `[canisters.<name>.check-stable].path` to it. Configurable via `[deployed].dir` (default `deployed`) and overridable with `--dir`; the build output dir it reads from defaults to `[build].outputDir` (`.mops/.build`) and is overridable with `--build-dir`.
+
+- Add `mops generate candid [canisters...]` to (re)generate the curated `.did` file from current Motoko source. With `[canisters.<name>].candid` set, overwrites that file in place; otherwise writes `<name>.did` next to `main` and sets the field in `mops.toml`. `--output, -o <path>` writes to an arbitrary path (single-canister only) without modifying `mops.toml`. `moc` is invoked with the same packages, `[moc].args`, `[build].args`, per-canister `args`, and migration flags as `mops build`, so the generated interface always satisfies `mops build`'s subtype check.
+
 ## 2.14.1
 - Speed up `mops check <files...>` (e.g. `mops check src/**/*.mo`) on packages with many files. Previously each file was checked in its own `moc` invocation, so every shared transitive import was re-parsed and re-type-checked once per file. All files are now passed to a single `moc --check` call, which loads and type-checks each import only once — on motoko-core (53 files) this drops a full check from ~27s to ~1.6s. The per-file `✓` confirmations now print only when the whole check passes.
 

package/cli.ts

@@ -13,9 +13,11 @@ import { bump } from "./commands/bump.js";
 import { check } from "./commands/check.js";
 import { checkCandid } from "./commands/check-candid.js";
 import { checkStable } from "./commands/check-stable.js";
+import { deployed, deployedInit } from "./commands/deployed.js";
 import { docsCoverage } from "./commands/docs-coverage.js";
 import { docs } from "./commands/docs.js";
 import { format } from "./commands/format.js";
+import { generateCandid } from "./commands/generate.js";
 import { info } from "./commands/info.js";
 import { init } from "./commands/init.js";
 import { lint } from "./commands/lint.js";
@@ -97,6 +99,19 @@ function parseExtraArgs(variadicArgs?: string[]): {
   return { extraArgs, args };
 }
 
+// Shared `--help` section describing the enhanced migration `check-limit`
+// trimming and its override flag, so the limit behaviour is discoverable
+// from `--help`. `withFix` appends the `--fix` hint for commands that support it.
+function enhancedMigrationHelp(withFix: boolean): string {
+  const example = withFix ? " (e.g. to --fix older migrations)" : "";
+  return (
+    "\nEnhanced migration ([canisters.<name>.migrations]):\n" +
+    "  The canister is checked against its migration chain. [migrations].check-limit\n" +
+    "  trims it to the last N migrations (older ones are skipped). Pass --no-check-limit\n" +
+    `  to use the full chain${example}.`
+  );
+}
+
 program.name("mops");
 
 // --version
@@ -116,7 +131,7 @@ program
   .command("add <pkg>")
   .description("Install the package and save it to mops.toml")
   .option("--dev", "Add to [dev-dependencies] section")
-  .option("--verbose")
+  .option("--verbose", "Show more information")
   .addOption(
     new Option("--lock <action>", "Lockfile action").choices([
       "update",
@@ -157,7 +172,7 @@ program
   .alias("i")
   .description("Install all dependencies specified in mops.toml")
   .option("--no-toolchain", "Do not install toolchain")
-  .option("--verbose")
+  .option("--verbose", "Show more information")
   .addOption(
     new Option("--lock <action>", "Lockfile action").choices([
       "check",
@@ -200,7 +215,7 @@ program
   .option("--no-docs", "Do not generate docs")
   .option("--no-test", "Do not run tests")
   .option("--no-bench", "Do not run benchmarks")
-  .option("--verbose")
+  .option("--verbose", "Show more information")
   .action(async (options) => {
     if (!checkConfigFile()) {
       process.exit(1);
@@ -313,6 +328,18 @@ program
   .description("Build a canister")
   .addOption(new Option("--verbose", "Verbose console output"))
   .addOption(new Option("--output, -o <output>", "Output directory"))
+  .addHelpText(
+    "after",
+    "\nArguments after -- are forwarded directly to moc, e.g.:\n  $ mops build -- -Werror",
+  )
+  .addHelpText(
+    "after",
+    "\nEnhanced migration ([canisters.<name>.migrations]):\n" +
+      "  The canister is built against its full migration chain (every migration is\n" +
+      "  compiled into the wasm). If mops check passes but mops build fails while\n" +
+      "  [migrations].check-limit is set, re-run with mops check --no-check-limit to\n" +
+      "  surface the issue (check trims the chain; build compiles all of it).",
+  )
   .allowUnknownOption(true) // TODO: restrict unknown before "--"
   .action(async (canisters, options) => {
     checkConfigFile(true);
@@ -342,6 +369,17 @@ program
       "Apply autofixes to all files, including transitively imported ones",
     ),
   )
+  .addOption(
+    new Option(
+      "--no-check-limit",
+      "Check the full migration chain, ignoring [migrations].check-limit",
+    ),
+  )
+  .addHelpText(
+    "after",
+    "\nArguments after -- are forwarded directly to moc, e.g.:\n  $ mops check -- -Werror",
+  )
+  .addHelpText("after", enhancedMigrationHelp(true))
   .allowUnknownOption(true)
   .action(async (args, options) => {
     checkConfigFile(true);
@@ -378,6 +416,17 @@ program
     "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")
+  .addOption(
+    new Option(
+      "--no-check-limit",
+      "Check the full migration chain, ignoring [migrations].check-limit",
+    ),
+  )
+  .addHelpText(
+    "after",
+    "\nArguments after -- are forwarded directly to moc, e.g.:\n  $ mops check-stable -- -Werror",
+  )
+  .addHelpText("after", enhancedMigrationHelp(false))
   .allowUnknownOption(true)
   .action(async (args, options) => {
     checkConfigFile(true);
@@ -393,6 +442,47 @@ program
     });
   });
 
+// deployed
+const deployedCommand = new Command("deployed")
+  .description(
+    "Post-deploy hook: promote .most stable-types files into the deployed directory so `mops check-stable` compares against the just-deployed version. Pass canister names to scope; with no arguments, all canisters in mops.toml are promoted",
+  )
+  .argument("[canisters...]")
+  .addOption(
+    new Option(
+      "--build-dir <dir>",
+      "Directory to read built .most files from (default: [build].outputDir or .mops/.build)",
+    ),
+  )
+  .addOption(
+    new Option(
+      "--dir <dir>",
+      "Destination directory (default: [deployed].dir or deployed)",
+    ),
+  )
+  .action(async (canisters: string[], options) => {
+    checkConfigFile(true);
+    await deployed(canisters.length ? canisters : undefined, options);
+  });
+
+deployedCommand
+  .command("init [canisters...]")
+  .description(
+    "Pre-first-deploy bootstrap: create an empty-actor .most baseline in the deployed directory and wire [canisters.<name>.check-stable].path to it. Idempotent",
+  )
+  .addOption(
+    new Option(
+      "--dir <dir>",
+      "Destination directory (default: [deployed].dir or deployed)",
+    ),
+  )
+  .action(async (canisters: string[], options) => {
+    checkConfigFile(true);
+    await deployedInit(canisters.length ? canisters : undefined, options);
+  });
+
+program.addCommand(deployedCommand);
+
 // test
 program
   .command("test [filter]")
@@ -453,7 +543,12 @@ program
     ),
   )
   // .addOption(new Option('--force-gc', 'Force GC'))
-  .addOption(new Option("--verbose", "Show more information"))
+  .addOption(
+    new Option(
+      "--verbose",
+      "Print the benchmark pipeline (compiler, replica, GC, optimization) and stream compiler/replica output, including dfx optimization warnings",
+    ),
+  )
   .action(async (filter, options) => {
     checkConfigFile(true);
     await installAll({
@@ -769,6 +864,44 @@ migrateCommand
 
 program.addCommand(migrateCommand);
 
+// generate
+const generateCommand = new Command("generate")
+  .description("Generate source-derived artifacts (Candid, ...)")
+  .showHelpAfterError();
+
+generateCommand
+  .command("candid [canisters...]")
+  .description(
+    "(Re)generate the curated `.did` file for one or more canisters from current Motoko source. With no canister names, generates for all canisters in mops.toml. When [canisters.<name>].candid is set, overwrites that file; otherwise writes <name>.did next to `main` and sets the field.",
+  )
+  .addOption(
+    new Option(
+      "--output, -o <output>",
+      "Write the generated .did to <output> (single-canister only; does not touch mops.toml)",
+    ),
+  )
+  .addOption(new Option("--verbose", "Verbose console output"))
+  .addHelpText(
+    "after",
+    "\nArguments after -- are forwarded directly to moc, e.g.:\n  $ mops generate candid -- -Werror",
+  )
+  .allowUnknownOption(true)
+  .action(async (canisters, options) => {
+    checkConfigFile(true);
+    const { extraArgs, args } = parseExtraArgs(canisters);
+    await installAll({
+      silent: true,
+      lock: "ignore",
+      installFromLockFile: true,
+    });
+    await generateCandid(args.length ? args : undefined, {
+      ...options,
+      extraArgs,
+    });
+  });
+
+program.addCommand(generateCommand);
+
 // self
 const selfCommand = new Command("self").description("Mops CLI management");
 
@@ -836,6 +969,17 @@ program
       "Directories containing rules (can be used multiple times)",
     ),
   )
+  .addOption(
+    new Option(
+      "--no-check-limit",
+      "Lint the full migration chain, ignoring [migrations].check-limit",
+    ),
+  )
+  .addHelpText(
+    "after",
+    "\nArguments after -- are forwarded directly to lintoko, e.g.:\n  $ mops lint -- --severity warning",
+  )
+  .addHelpText("after", enhancedMigrationHelp(true))
   .allowUnknownOption(true)
   .action(async (filter, options) => {
     checkConfigFile(true);
@@ -843,6 +987,7 @@ program
     await lint(filter, {
       ...options,
       extraArgs,
+      noCheckLimit: options.checkLimit === false,
     });
   });
 

package/commands/bench-replica.ts

@@ -74,7 +74,8 @@ export class BenchReplica {
     if (this.type === "dfx" || this.type === "dfx-pocket-ic") {
       await execaCommand(
         `dfx deploy ${name} --mode reinstall --yes --identity anonymous`,
-        { cwd, stdio: this.verbose ? "pipe" : ["pipe", "ignore", "pipe"] },
+        // `inherit` so dfx output is streamed under --verbose (incl. its `Failed to optimize` warning)
+        { cwd, stdio: this.verbose ? "inherit" : ["pipe", "ignore", "pipe"] },
       );
       let canisterId = execSync(`dfx canister id ${name}`, { cwd })
         .toString()

package/commands/bench.ts

@@ -101,7 +101,28 @@ export async function bench(
 
   warnIfDfxReplica(replicaType, optionsArg.replica === "dfx");
 
-  options.verbose && console.log(options);
+  if (options.verbose) {
+    // `dfx` post-optimizes the wasm on deploy (`optimize: "cycles"`, via ic-wasm);
+    // `pocket-ic` runs the raw moc output. This changes instruction counts, so surface it.
+    let optimize =
+      replicaType === "dfx" || replicaType === "dfx-pocket-ic"
+        ? 'dfx `optimize: "cycles"` (ic-wasm) on deploy'
+        : "none (raw moc output)";
+    console.log(chalk.gray("Benchmark pipeline:"));
+    console.log(chalk.gray(`  compiler:  moc ${options.compilerVersion}`));
+    console.log(
+      chalk.gray(
+        `  replica:   ${replicaType}${options.replicaVersion ? ` ${options.replicaVersion}` : ""}`,
+      ),
+    );
+    console.log(
+      chalk.gray(
+        `  gc:        ${options.gc}${options.forceGc ? " (forced)" : ""}`,
+      ),
+    );
+    console.log(chalk.gray(`  profile:   ${options.profile}`));
+    console.log(chalk.gray(`  optimize:  ${optimize}`));
+  }
 
   let replica = new BenchReplica(replicaType, options.verbose);
 
@@ -303,14 +324,16 @@ async function deployBenchFile(
   // build canister
   let mocPath = getMocPath();
   let mocArgs = getMocArgs(options);
-  options.verbose && console.time(`build ${canisterName}`);
-  await execaCommand(
-    `${mocPath} -c --idl canister.mo ${globalMocArgs.join(" ")} ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`,
-    {
-      cwd: tempDir,
-      stdio: options.verbose ? "pipe" : ["pipe", "ignore", "pipe"],
-    },
-  );
+  let buildCmd = `${mocPath} -c --idl canister.mo ${globalMocArgs.join(" ")} ${mocArgs} ${(await sources({ cwd: tempDir })).join(" ")}`;
+  if (options.verbose) {
+    console.log(chalk.gray(`[${canisterName}] ${buildCmd}`));
+    console.time(`build ${canisterName}`);
+  }
+  await execaCommand(buildCmd, {
+    cwd: tempDir,
+    // `inherit` so the compiler output (warnings/errors) is streamed under --verbose
+    stdio: options.verbose ? "inherit" : ["pipe", "ignore", "pipe"],
+  });
   options.verbose && console.timeEnd(`build ${canisterName}`);
 
   // deploy canister

package/commands/build.ts

@@ -9,13 +9,11 @@ import { isCandidCompatible } from "../helpers/is-candid-compatible.js";
 import {
   filterCanisters,
   resolveCanisterConfigs,
-  validateCanisterArgs,
 } from "../helpers/resolve-canisters.js";
-import { prepareMigrationArgs } from "../helpers/migrations.js";
-import { CanisterConfig, Config } from "../types.js";
+import { BUILD_MANAGED_FLAGS, prepareMocArgs } from "../helpers/moc-args.js";
 import { CustomSection, getWasmBindings } from "../wasm.js";
-import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
-import { sourcesArgs } from "./sources.js";
+import { readConfig, resolveConfigPath } from "../mops.js";
+import { Config } from "../types.js";
 import { toolchain } from "./toolchain/index.js";
 
 export interface BuildOptions {
@@ -26,6 +24,22 @@ export interface BuildOptions {
 
 export const DEFAULT_BUILD_OUTPUT_DIR = ".mops/.build";
 
+/**
+ * Resolve the build output directory: CLI override → `[build].outputDir`
+ * (project-root-relative, resolved via `resolveConfigPath`) → default.
+ */
+export function resolveBuildOutputDir(
+  config: Config,
+  override?: string,
+): string {
+  if (override) {
+    return override;
+  }
+  return config.build?.outputDir
+    ? resolveConfigPath(config.build.outputDir)
+    : DEFAULT_BUILD_OUTPUT_DIR;
+}
+
 export async function build(
   canisterNames: string[] | undefined,
   options: Partial<BuildOptions>,
@@ -35,11 +49,7 @@ export async function build(
   }
 
   let config = readConfig();
-  let configOutputDir = config.build?.outputDir
-    ? resolveConfigPath(config.build.outputDir)
-    : undefined;
-  let outputDir =
-    options.outputDir ?? configOutputDir ?? DEFAULT_BUILD_OUTPUT_DIR;
+  let outputDir = resolveBuildOutputDir(config, options.outputDir);
   let mocPath = await toolchain.bin("moc", { fallback: true });
   let canisters = resolveCanisterConfigs(config);
   if (!Object.keys(canisters).length) {
@@ -54,11 +64,6 @@ export async function build(
 
   for (let [canisterName, canister] of Object.entries(filteredCanisters)) {
     console.log(chalk.blue("build canister"), chalk.bold(canisterName));
-    let motokoPath = canister.main;
-    if (!motokoPath) {
-      cliError(`No main file is specified for canister ${canisterName}`);
-    }
-    motokoPath = resolveConfigPath(motokoPath);
     const wasmPath = join(outputDir, `${canisterName}.wasm`);
     const mostPath = join(outputDir, `${canisterName}.most`);
 
@@ -88,12 +93,13 @@ export async function build(
     };
     process.on("exit", exitCleanup);
 
-    const migration = await prepareMigrationArgs(
-      canister.migrations,
-      canisterName,
-      "build",
-      options.verbose,
-    );
+    const prepared = await prepareMocArgs(config, canister, canisterName, {
+      mode: "build",
+      managedFlags: BUILD_MANAGED_FLAGS,
+      commandName: "mops build",
+      verbose: options.verbose,
+      extraArgs: options.extraArgs,
+    });
     try {
       let args = [
         "-c",
@@ -101,14 +107,9 @@ export async function build(
         "--stable-types",
         "-o",
         wasmPath,
-        motokoPath,
-        ...(await sourcesArgs()).flat(),
-        ...getGlobalMocArgs(config),
-        ...migration.migrationArgs,
+        prepared.motokoPath,
+        ...prepared.args,
       ];
-      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";
@@ -207,7 +208,7 @@ export async function build(
         );
       }
     } finally {
-      await migration.cleanup();
+      await prepared.cleanup();
       process.removeListener("exit", exitCleanup);
       try {
         await release?.();
@@ -221,51 +222,3 @@ export async function build(
     ),
   );
 }
-
-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",
-};
-
-function collectExtraArgs(
-  config: Config,
-  canister: CanisterConfig,
-  canisterName: string,
-  extraArgs?: string[],
-): string[] {
-  const args: string[] = [];
-
-  if (config.build?.args) {
-    if (typeof config.build.args === "string") {
-      cliError(
-        `[build] config 'args' should be an array of strings in mops.toml config file`,
-      );
-    }
-    args.push(...config.build.args);
-  }
-  if (canister.args) {
-    validateCanisterArgs(canister, canisterName, config);
-    args.push(...canister.args);
-  }
-  if (extraArgs) {
-    args.push(...extraArgs);
-  }
-
-  const warned = new Set<string>();
-  for (const arg of args) {
-    const hint = managedFlags[arg];
-    if (hint && !warned.has(arg)) {
-      warned.add(arg);
-      console.warn(
-        chalk.yellow(
-          `Warning: '${arg}' in args for canister ${canisterName} may conflict with mops build — ${hint}`,
-        ),
-      );
-    }
-  }
-
-  return args;
-}

package/commands/check-stable.ts

@@ -25,6 +25,8 @@ const CHECK_STABLE_PREFIX = ".check-stable-";
 export interface CheckStableOptions {
   verbose: boolean;
   extraArgs: string[];
+  /** Commander `--no-check-limit`: false ignores [migrations].check-limit. */
+  checkLimit: boolean;
 }
 
 export function resolveStablePath(
@@ -91,6 +93,7 @@ export async function checkStable(
       name,
       "check",
       options.verbose,
+      options.checkLimit === false,
     );
     try {
       await runStableCheck({
@@ -132,6 +135,7 @@ export async function checkStable(
       name,
       "check",
       options.verbose,
+      options.checkLimit === false,
     );
     try {
       await runStableCheck({

package/commands/check.ts

@@ -35,6 +35,8 @@ export interface CheckOptions {
   verbose: boolean;
   fix: boolean;
   extraArgs: string[];
+  /** Commander `--no-check-limit`: false ignores [migrations].check-limit. */
+  checkLimit: boolean;
 }
 
 function checkAllLibsSupport(verbose?: boolean): boolean {
@@ -135,6 +137,7 @@ async function checkImpl(
       fix: options.fix,
       rules: lintRules,
       files: lintFiles,
+      noCheckLimit: options.checkLimit === false,
     });
   }
 }
@@ -164,6 +167,7 @@ async function checkCanisters(
       canisterName,
       "check",
       options.verbose,
+      options.checkLimit === false,
     );
     try {
       const mocArgs = [
@@ -262,30 +266,30 @@ async function checkFiles(
     logAutofixResult(fixResult, options.verbose);
   }
 
-  // Check all files in a single moc invocation so shared transitive imports
-  // are chased and type-checked once, not re-checked for every file.
-  const args = [...files, ...mocArgs];
-  if (options.verbose) {
-    console.log(chalk.blue("check"), chalk.gray("Running moc:"));
-    console.log(chalk.gray(mocPath, JSON.stringify(args)));
-  }
+  for (const file of files) {
+    try {
+      const args = [file, ...mocArgs];
+      if (options.verbose) {
+        console.log(chalk.blue("check"), chalk.gray("Running moc:"));
+        console.log(chalk.gray(mocPath, JSON.stringify(args)));
+      }
 
-  try {
-    const result = await execa(mocPath, args, {
-      stdio: "inherit",
-      reject: false,
-    });
+      const result = await execa(mocPath, args, {
+        stdio: "inherit",
+        reject: false,
+      });
 
-    if (result.exitCode !== 0) {
-      cliError(`✗ Check failed (exit code: ${result.exitCode})`);
-    }
-  } catch (err: any) {
-    cliError(
-      `Error while checking files${err?.message ? `\n${err.message}` : ""}`,
-    );
-  }
+      if (result.exitCode !== 0) {
+        cliError(
+          `✗ Check failed for file ${file} (exit code: ${result.exitCode})`,
+        );
+      }
 
-  for (const file of files) {
-    console.log(chalk.green(`✓ ${file}`));
+      console.log(chalk.green(`✓ ${file}`));
+    } catch (err: any) {
+      cliError(
+        `Error while checking ${file}${err?.message ? `\n${err.message}` : ""}`,
+      );
+    }
   }
 }