ic-mops 2.13.2 → 2.14.1

package/commands/install/install-mops-dep.ts

@@ -4,15 +4,17 @@ import path from "node:path";
 import { Buffer } from "node:buffer";
 import { createLogUpdate } from "log-update";
 import chalk from "chalk";
-import { deleteSync } from "del";
 import { checkConfigFile, progressBar, readConfig } from "../../mops.js";
 import { getHighestVersion } from "../../api/getHighestVersion.js";
 import { storageActor } from "../../api/actors.js";
 import { parallel } from "../../parallel.js";
 import {
+  commitStagingDir,
+  createStagingDir,
   getDepCacheDir,
   getMopsDepCacheName,
   isDepCached,
+  sweepStaleStagingDirs,
 } from "../../cache.js";
 import {
   downloadFile,
@@ -69,6 +71,8 @@ export async function installMopsDep(
     version = versionRes.ok;
   }
 
+  sweepStaleStagingDirs();
+
   let cacheName = getMopsDepCacheName(depName, version);
   let cacheDir = getDepCacheDir(cacheName);
 
@@ -100,33 +104,34 @@ export async function installMopsDep(
         progress();
       });
 
+      let stagingDir = createStagingDir(cacheDir);
       let onSigInt = () => {
-        deleteSync([cacheDir], { force: true });
-        process.exit();
+        fs.rmSync(stagingDir, { recursive: true, force: true });
+        process.exit(130);
       };
       process.on("SIGINT", onSigInt);
 
-      // write files to global cache
       try {
         await Promise.all(
           Array.from(filesData.entries()).map(async ([filePath, data]) => {
             await fs.promises.mkdir(
-              path.join(cacheDir, path.dirname(filePath)),
+              path.join(stagingDir, path.dirname(filePath)),
               { recursive: true },
             );
             await fs.promises.writeFile(
-              path.join(cacheDir, filePath),
+              path.join(stagingDir, filePath),
               Buffer.from(data),
             );
           }),
         );
+        commitStagingDir(stagingDir, cacheDir);
       } catch (err) {
         console.error(chalk.red("Error: ") + err);
-        deleteSync([cacheDir], { force: true });
+        fs.rmSync(stagingDir, { recursive: true, force: true });
         return false;
+      } finally {
+        process.off("SIGINT", onSigInt);
       }
-
-      process.off("SIGINT", onSigInt);
     } catch (err) {
       console.error(chalk.red("Error: ") + err);
       return false;

package/commands/install/sync-local-cache.ts

@@ -1,12 +1,18 @@
 import fs from "node:fs";
 import path from "node:path";
-import { copyCache, getDepCacheName } from "../../cache.js";
+import {
+  copyCache,
+  getDepCacheName,
+  sweepStaleStagingDirs,
+} from "../../cache.js";
 import { getDependencyType, getRootDir } from "../../mops.js";
 import { resolvePackages } from "../../resolve-packages.js";
 
 export async function syncLocalCache({ verbose = false } = {}): Promise<
   Record<string, string>
 > {
+  sweepStaleStagingDirs();
+
   let resolvedPackages = await resolvePackages();
   let rootDir = getRootDir();
 

package/commands/lint.ts

@@ -11,6 +11,7 @@ import {
   readConfig,
 } from "../mops.js";
 import { resolvePackages } from "../resolve-packages.js";
+import { withFixLock } from "../helpers/fix-lock.js";
 import { toolchain } from "./toolchain/index.js";
 import { MOTOKO_GLOB_CONFIG } from "../constants.js";
 import { existsSync } from "node:fs";
@@ -174,6 +175,16 @@ async function runLintoko(
 export async function lint(
   filter: string | undefined,
   options: Partial<LintOptions>,
+): Promise<void> {
+  if (options.fix) {
+    return withFixLock(() => lintImpl(filter, options));
+  }
+  return lintImpl(filter, options);
+}
+
+async function lintImpl(
+  filter: string | undefined,
+  options: Partial<LintOptions>,
 ): Promise<void> {
   let config = readConfig();
   let rootDir = getRootDir();

package/commands/outdated.ts

@@ -3,7 +3,10 @@ import { checkConfigFile, readConfig } from "../mops.js";
 import { getAvailableUpdates } from "./available-updates.js";
 import { getDepName, getDepPinnedVersion } from "../helpers/get-dep-name.js";
 
-export async function outdated({ major }: { major?: boolean } = {}) {
+export async function outdated({
+  major,
+  patch,
+}: { major?: boolean; patch?: boolean } = {}) {
   if (!checkConfigFile()) {
     return;
   }
@@ -12,7 +15,7 @@ export async function outdated({ major }: { major?: boolean } = {}) {
   let available = await getAvailableUpdates(
     config,
     undefined,
-    major ? "major" : "caret",
+    major ? "major" : patch ? "patch" : "caret",
   );
 
   if (available.length === 0) {

package/commands/publish.ts

@@ -336,7 +336,6 @@ export async function publish(
     console.log("Running benchmarks...");
     try {
       benchmarks = await bench("", {
-        replica: config.toolchain?.["pocket-ic"] ? "pocket-ic" : "dfx",
         gc: "copying",
         forceGc: true,
         silent: true,

package/commands/test/test.ts

@@ -32,6 +32,7 @@ import { toolchain } from "../toolchain/index.js";
 import { Replica } from "../replica.js";
 import { TestMode } from "../../types.js";
 import { getDfxVersion } from "../../helpers/get-dfx-version.js";
+import { warnIfDfxReplica } from "../../helpers/deprecate-dfx-replica.js";
 import { MOTOKO_GLOB_CONFIG, MOTOKO_IGNORE_PATTERNS } from "../../constants.js";
 
 type ReporterName = "verbose" | "files" | "compact" | "silent";
@@ -79,6 +80,8 @@ export async function test(filter = "", options: Partial<TestOptions> = {}) {
     }
   }
 
+  let explicitReplica = options.replica === "dfx";
+
   replica.type = replicaType;
   replica.verbose = !!options.verbose;
 
@@ -124,6 +127,7 @@ export async function test(filter = "", options: Partial<TestOptions> = {}) {
         replicaType,
         true,
         controller.signal,
+        explicitReplica,
       );
       await curRun;
 
@@ -150,6 +154,9 @@ export async function test(filter = "", options: Partial<TestOptions> = {}) {
       filter,
       options.mode,
       replicaType,
+      false,
+      undefined,
+      explicitReplica,
     );
     if (!passed) {
       process.exit(1);
@@ -167,6 +174,7 @@ async function runAll(
   replicaType: ReplicaName,
   watch = false,
   signal?: AbortSignal,
+  explicitReplica = false,
 ): Promise<boolean> {
   let done = await testWithReporter(
     reporterName,
@@ -175,6 +183,7 @@ async function runAll(
     replicaType,
     watch,
     signal,
+    explicitReplica,
   );
   return done;
 }
@@ -186,6 +195,7 @@ export async function testWithReporter(
   replicaType: ReplicaName,
   watch = false,
   signal?: AbortSignal,
+  explicitReplica = false,
 ): Promise<boolean> {
   let rootDir = getRootDir();
   let files: string[] = [];
@@ -261,6 +271,10 @@ export async function testWithReporter(
   let hasWasiTests = filesWithMode.some(({ mode }) => mode === "wasi");
   let hasReplicaTests = filesWithMode.some(({ mode }) => mode === "replica");
 
+  if (hasReplicaTests) {
+    warnIfDfxReplica(replicaType, explicitReplica);
+  }
+
   // prepare wasmtime path
   if (hasWasiTests && !wasmtimePath) {
     // ensure wasmtime is installed or specified in config

package/commands/update.ts

@@ -15,11 +15,12 @@ type UpdateOptions = {
   dev?: boolean;
   lock?: "update" | "ignore";
   major?: boolean;
+  patch?: boolean;
 };
 
 export async function update(
   pkg?: string,
-  { lock, major }: UpdateOptions = {},
+  { lock, major, patch }: UpdateOptions = {},
 ) {
   if (!checkConfigFile()) {
     return;
@@ -66,7 +67,7 @@ export async function update(
   let available = await getAvailableUpdates(
     config,
     pkg,
-    major ? "major" : "caret",
+    major ? "major" : patch ? "patch" : "caret",
   );
 
   if (available.length === 0) {

package/commands/watch/tester.ts

@@ -3,6 +3,7 @@ import { readConfig } from "../../mops.js";
 import { ErrorChecker } from "./error-checker.js";
 import { testWithReporter } from "../test/test.js";
 import { SilentReporter } from "../test/reporters/silent-reporter.js";
+import { type ReplicaName } from "../../helpers/deprecate-dfx-replica.js";
 
 export class Tester {
   verbose = false;
@@ -53,12 +54,15 @@ export class Tester {
     this.controller = new AbortController();
 
     let config = readConfig();
+    let replicaType: ReplicaName = config.toolchain?.["pocket-ic"]
+      ? "pocket-ic"
+      : "dfx";
 
     this.currentRun = testWithReporter(
       this.reporter,
       "",
       "interpreter",
-      config.toolchain?.["pocket-ic"] ? "pocket-ic" : "dfx",
+      replicaType,
       true,
       this.controller.signal,
     );

package/dist/cache.d.ts

@@ -1,3 +1,6 @@
+export declare function createStagingDir(dest: string): string;
+export declare function commitStagingDir(staging: string, dest: string): boolean;
+export declare function sweepStaleStagingDirs(): void;
 export declare let show: () => string;
 export declare let getDepCacheDir: (cacheName: string) => string;
 export declare let isDepCached: (cacheName: string) => boolean;

package/dist/cache.js

@@ -8,6 +8,72 @@ let getGlobalCacheDir = () => {
     let network = getNetwork();
     return path.join(globalCacheDir, network === "ic" ? "" : network);
 };
+// Cache writes stage into a sibling `<dest>/../.staging-<rand>` and atomic-
+// rename onto `dest` so concurrent processes never observe a partial cache.
+const STAGING_PREFIX = ".staging-";
+export function createStagingDir(dest) {
+    let parent = path.dirname(dest);
+    fs.mkdirSync(parent, { recursive: true });
+    return fs.mkdtempSync(path.join(parent, STAGING_PREFIX));
+}
+// Returns false if another process committed first (race lost) — `staging`
+// is removed and the existing `dest` is left intact. We only swallow
+// `EPERM` (Windows) when `dest` exists; otherwise it's likely AV / open
+// handles and bubbles up.
+export function commitStagingDir(staging, dest) {
+    try {
+        fs.renameSync(staging, dest);
+        return true;
+    }
+    catch (err) {
+        let raceLost = (err.code === "ENOTEMPTY" ||
+            err.code === "EEXIST" ||
+            err.code === "EPERM") &&
+            fs.existsSync(dest);
+        if (raceLost) {
+            fs.rmSync(staging, { recursive: true, force: true });
+            return false;
+        }
+        throw err;
+    }
+}
+// Sweep leftover `.staging-*` from interrupted runs. Mtime cutoff avoids
+// clobbering siblings that are mid-staging right now. Runs at most once
+// per process.
+const STAGING_STALE_MS = 60 * 60 * 1000;
+let swept = false;
+export function sweepStaleStagingDirs() {
+    if (swept) {
+        return;
+    }
+    swept = true;
+    let cutoff = Date.now() - STAGING_STALE_MS;
+    let parents = [
+        path.join(getGlobalCacheDir(), "packages"),
+        path.join(getGlobalCacheDir(), "packages", "_github"),
+        path.join(getRootDir(), ".mops"),
+        path.join(getRootDir(), ".mops", "_github"),
+    ];
+    for (let parent of parents) {
+        if (!fs.existsSync(parent)) {
+            continue;
+        }
+        for (let entry of fs.readdirSync(parent)) {
+            if (!entry.startsWith(STAGING_PREFIX)) {
+                continue;
+            }
+            let full = path.join(parent, entry);
+            try {
+                if (fs.statSync(full).mtimeMs < cutoff) {
+                    fs.rmSync(full, { recursive: true, force: true });
+                }
+            }
+            catch {
+                // raced with another sweeper; ignore
+            }
+        }
+    }
+}
 export let show = () => {
     return getGlobalCacheDir();
 };
@@ -32,29 +98,43 @@ export function getGithubDepCacheName(name, repo) {
     return (`_github/${name}#${branch.replaceAll("/", "___")}` +
         (commitHash ? `@${commitHash}` : ""));
 }
-export let addCache = (cacheName, source) => {
+export let addCache = async (cacheName, source) => {
     let dest = path.join(getGlobalCacheDir(), "packages", cacheName);
-    fs.mkdirSync(dest, { recursive: true });
-    return new Promise((resolve, reject) => {
-        ncp.ncp(source, dest, { stopOnErr: true }, (err) => {
-            if (err) {
-                reject(err);
-            }
-            resolve();
+    let staging = createStagingDir(dest);
+    try {
+        await new Promise((resolve, reject) => {
+            ncp.ncp(source, staging, { stopOnErr: true }, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                resolve();
+            });
         });
-    });
+        commitStagingDir(staging, dest);
+    }
+    catch (err) {
+        fs.rmSync(staging, { recursive: true, force: true });
+        throw err;
+    }
 };
-export let copyCache = (cacheName, dest) => {
+export let copyCache = async (cacheName, dest) => {
     let source = path.join(getGlobalCacheDir(), "packages", cacheName);
-    fs.mkdirSync(dest, { recursive: true });
-    return new Promise((resolve, reject) => {
-        ncp.ncp(source, dest, { stopOnErr: true }, (err) => {
-            if (err) {
-                reject(err);
-            }
-            resolve();
+    let staging = createStagingDir(dest);
+    try {
+        await new Promise((resolve, reject) => {
+            ncp.ncp(source, staging, { stopOnErr: true }, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                resolve();
+            });
         });
-    });
+        commitStagingDir(staging, dest);
+    }
+    catch (err) {
+        fs.rmSync(staging, { recursive: true, force: true });
+        throw err;
+    }
 };
 export let cacheSize = async () => {
     let dir = path.join(getGlobalCacheDir());

package/dist/cli.js

@@ -327,7 +327,7 @@ program
     .addOption(new Option("--mode <mode>", "Test mode")
     .choices(["interpreter", "wasi", "replica"])
     .default("interpreter"))
-    .addOption(new Option("--replica <replica>", "Which replica to use to run tests in replica mode").choices(["dfx", "pocket-ic"]))
+    .addOption(new Option("--replica <replica>", "Which replica to use to run tests in replica mode (`dfx` is deprecated; prefer `pocket-ic`)").choices(["dfx", "pocket-ic"]))
     .option("-w, --watch", "Enable watch mode")
     .option("--verbose", "Verbose output")
     .action(async (filter, options) => {
@@ -343,7 +343,7 @@ program
 program
     .command("bench [filter]")
     .description("Run benchmarks")
-    .addOption(new Option("--replica <replica>", "Which replica to use to run benchmarks").choices(["dfx", "pocket-ic"]))
+    .addOption(new Option("--replica <replica>", "Which replica to use to run benchmarks (`dfx` is deprecated; prefer `pocket-ic`)").choices(["dfx", "pocket-ic"]))
     .addOption(new Option("--gc <gc>", "Garbage collector")
     .choices(["copying", "compacting", "generational", "incremental"])
     .default("copying"))
@@ -491,16 +491,18 @@ program
 // outdated
 program
     .command("outdated")
-    .description("Print outdated dependencies specified in mops.toml")
-    .addOption(new Option("--major", "Allow updates that cross the caret bound (major versions, or for 0.x.y packages, minor versions)"))
+    .description("Print outdated dependencies in mops.toml within the caret bound (does not cross major versions, or pre-1.0 minor versions)")
+    .addOption(new Option("--major", "Allow updates that cross the caret bound (major versions, or for 0.x.y packages, minor versions)").conflicts("patch"))
+    .addOption(new Option("--patch", "Restrict updates to patch versions only (e.g. 1.2.3 -> 1.2.4, never 1.2.3 -> 1.3.0)"))
     .action(async (options) => {
     await outdated(options);
 });
 // update
 program
     .command("update [pkg]")
-    .description("Update dependencies specified in mops.toml")
-    .addOption(new Option("--major", "Allow updates that cross the caret bound (major versions, or for 0.x.y packages, minor versions)"))
+    .description("Update dependencies in mops.toml to the highest semver-compatible version within the caret bound (does not cross major versions, or pre-1.0 minor versions)")
+    .addOption(new Option("--major", "Allow updates that cross the caret bound (major versions, or for 0.x.y packages, minor versions)").conflicts("patch"))
+    .addOption(new Option("--patch", "Restrict updates to patch versions only (e.g. 1.2.3 -> 1.2.4, never 1.2.3 -> 1.3.0)"))
     .addOption(new Option("--lock <action>", "Lockfile action").choices([
     "update",
     "ignore",
@@ -509,7 +511,9 @@ program
     await update(pkg, options);
 });
 // toolchain
-const toolchainCommand = new Command("toolchain").description("Toolchain management");
+const toolchainCommand = new Command("toolchain")
+    .description(`Toolchain management for ${TOOLCHAINS.map((s) => `"${s}"`).join(", ")}`)
+    .showHelpAfterError();
 toolchainCommand
     .command("init")
     .description("One-time initialization of toolchain management")
@@ -525,8 +529,8 @@ toolchainCommand
 toolchainCommand
     .command("use")
     .description("Install specified tool version and update mops.toml")
-    .addArgument(new Argument("<tool>").choices(TOOLCHAINS))
-    .addArgument(new Argument("[version]"))
+    .addArgument(new Argument("<tool>", "tool to install").choices(TOOLCHAINS))
+    .addArgument(new Argument("[version]", "version to install (defaults to interactive picker)"))
     .action(async (tool, version) => {
     if (!checkConfigFile()) {
         process.exit(1);
@@ -536,7 +540,7 @@ toolchainCommand
 toolchainCommand
     .command("update")
     .description("Update specified tool or all tools to the latest version and update mops.toml")
-    .addArgument(new Argument("[tool]").choices(TOOLCHAINS))
+    .addArgument(new Argument("[tool]", "tool to update (defaults to all configured tools)").choices(TOOLCHAINS))
     .action(async (tool) => {
     if (!checkConfigFile()) {
         process.exit(1);
@@ -545,8 +549,8 @@ toolchainCommand
 });
 toolchainCommand
     .command("bin")
-    .description(`Get path to the tool binary\n<tool> can be one of ${TOOLCHAINS.map((s) => `"${s}"`).join(", ")}`)
-    .addArgument(new Argument("<tool>").choices(TOOLCHAINS))
+    .description("Get path to the tool binary")
+    .addArgument(new Argument("<tool>", "tool to look up").choices(TOOLCHAINS))
     .addOption(new Option("--fallback", "Fallback to the moc that comes with dfx if moc is not specified in the [toolchain] section"))
     .action(async (tool, options) => {
     let bin = await toolchain.bin(tool, options);

package/dist/commands/available-updates.d.ts

@@ -1,3 +1,3 @@
 import { Config } from "../types.js";
-export type UpdateBound = "caret" | "major";
+export type UpdateBound = "patch" | "caret" | "major";
 export declare function getAvailableUpdates(config: Config, pkg?: string, bound?: UpdateBound): Promise<Array<[string, string, string]>>;

package/dist/commands/available-updates.js

@@ -29,7 +29,10 @@ export async function getAvailableUpdates(config, pkg, bound = "caret") {
         let semverPart = { major: null };
         let name = getDepName(dep.name);
         let pinnedVersion = getDepPinnedVersion(dep.name);
-        if (pinnedVersion) {
+        if (bound === "patch") {
+            semverPart = { patch: null };
+        }
+        else if (pinnedVersion) {
             semverPart =
                 pinnedVersion.split(".").length === 1
                     ? { minor: null }

package/dist/commands/bench.js

@@ -16,6 +16,7 @@ import { parallel } from "../parallel.js";
 import { absToRel } from "./test/utils.js";
 import { getMocVersion } from "../helpers/get-moc-version.js";
 import { getDfxVersion } from "../helpers/get-dfx-version.js";
+import { warnIfDfxReplica } from "../helpers/deprecate-dfx-replica.js";
 import { getMocPath } from "../helpers/get-moc-path.js";
 import { sources } from "./sources.js";
 import { MOTOKO_GLOB_CONFIG } from "../constants.js";
@@ -59,6 +60,7 @@ export async function bench(filter = "", optionsArg = {}) {
     else if (replicaType == "pocket-ic") {
         options.replicaVersion = config.toolchain?.["pocket-ic"] || "";
     }
+    warnIfDfxReplica(replicaType, optionsArg.replica === "dfx");
     options.verbose && console.log(options);
     let replica = new BenchReplica(replicaType, options.verbose);
     let rootDir = getRootDir();

package/dist/commands/check.js

@@ -4,6 +4,7 @@ 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 { withFixLock } from "../helpers/fix-lock.js";
 import { getMocSemVer } from "../helpers/get-moc-version.js";
 import { filterCanisters, looksLikeFile, resolveCanisterConfigs, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
 import { prepareMigrationArgs } from "../helpers/migrations.js";
@@ -42,6 +43,12 @@ function logAutofixResult(fixResult, verbose) {
     }
 }
 export async function check(args, options = {}) {
+    if (options.fix) {
+        return withFixLock(() => checkImpl(args, options));
+    }
+    return checkImpl(args, options);
+}
+async function checkImpl(args, options = {}) {
     const config = readConfig();
     const canisters = resolveCanisterConfigs(config);
     const hasCanisters = Object.keys(canisters).length > 0;
@@ -164,24 +171,26 @@ async function checkFiles(config, files, options) {
         const fixResult = await autofixMotoko(mocPath, files, mocArgs);
         logAutofixResult(fixResult, options.verbose);
     }
-    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)));
-            }
-            const result = await execa(mocPath, args, {
-                stdio: "inherit",
-                reject: false,
-            });
-            if (result.exitCode !== 0) {
-                cliError(`✗ Check failed for file ${file} (exit code: ${result.exitCode})`);
-            }
-            console.log(chalk.green(`✓ ${file}`));
-        }
-        catch (err) {
-            cliError(`Error while checking ${file}${err?.message ? `\n${err.message}` : ""}`);
+    // 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)));
+    }
+    try {
+        const result = await execa(mocPath, args, {
+            stdio: "inherit",
+            reject: false,
+        });
+        if (result.exitCode !== 0) {
+            cliError(`✗ Check failed (exit code: ${result.exitCode})`);
         }
     }
+    catch (err) {
+        cliError(`Error while checking files${err?.message ? `\n${err.message}` : ""}`);
+    }
+    for (const file of files) {
+        console.log(chalk.green(`✓ ${file}`));
+    }
 }

package/dist/commands/init.js

@@ -19,6 +19,14 @@ export async function init({ yes = false } = {}) {
     }
     console.log("Initializing...");
     let config = {};
+    let vesselFile = path.join(process.cwd(), "vessel.dhall");
+    let vesselExists = existsSync(vesselFile);
+    // Warn before the --yes early-return so scripted/CI users get the heads-up
+    // even though `mops init --yes` skips the vessel migration entirely.
+    if (vesselExists) {
+        console.warn(chalk.yellow("WARN: vessel.dhall auto-migration is deprecated and will be removed in mops v3. " +
+            "Before then, copy your dependencies into mops.toml manually and delete vessel.dhall / package-set.dhall."));
+    }
     if (yes) {
         await applyInit({
             type: "project",
@@ -30,9 +38,8 @@ export async function init({ yes = false } = {}) {
         return;
     }
     // migrate from vessel
-    let vesselFile = path.join(process.cwd(), "vessel.dhall");
     let vesselConfig = { dependencies: [], "dev-dependencies": [] };
-    if (existsSync(vesselFile)) {
+    if (vesselExists) {
         console.log("Reading vessel.dhall file");
         let res = await readVesselConfig(process.cwd(), { cache: false });
         if (res) {