ic-mops 2.13.1 → 2.14.0

package/commands/check.ts

@@ -9,6 +9,7 @@ import {
   resolveConfigPath,
 } from "../mops.js";
 import { AutofixResult, autofixMotoko } from "../helpers/autofix-motoko.js";
+import { withFixLock } from "../helpers/fix-lock.js";
 import { getMocSemVer } from "../helpers/get-moc-version.js";
 import {
   filterCanisters,
@@ -82,6 +83,16 @@ function logAutofixResult(
 export async function check(
   args: string[],
   options: Partial<CheckOptions> = {},
+): Promise<void> {
+  if (options.fix) {
+    return withFixLock(() => checkImpl(args, options));
+  }
+  return checkImpl(args, options);
+}
+
+async function checkImpl(
+  args: string[],
+  options: Partial<CheckOptions> = {},
 ): Promise<void> {
   const config = readConfig();
   const canisters = resolveCanisterConfigs(config);
@@ -216,7 +227,6 @@ async function checkCanisters(
           canisterArgs: [...migration.migrationArgs, ...(canister.args ?? [])],
           sources,
           options: { verbose: options.verbose, extraArgs: options.extraArgs },
-          hasMigrations: !!canister.migrations,
         });
       }
     } finally {

package/commands/init.ts

@@ -25,6 +25,20 @@ export async function init({ yes = false } = {}) {
 
   let config: 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",
@@ -37,10 +51,9 @@ export async function init({ yes = false } = {}) {
   }
 
   // migrate from vessel
-  let vesselFile = path.join(process.cwd(), "vessel.dhall");
   let vesselConfig: 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) {

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-stable.d.ts

@@ -16,6 +16,5 @@ export interface RunStableCheckParams {
     canisterArgs: string[];
     sources?: string[];
     options?: Partial<CheckStableOptions>;
-    hasMigrations?: boolean;
 }
 export declare function runStableCheck(params: RunStableCheckParams): Promise<void>;