ic-mops 2.14.1 → 2.15.1

package/dist/commands/build.js

@@ -6,22 +6,30 @@ 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 { filterCanisters, resolveCanisterConfigs, validateCanisterArgs, } from "../helpers/resolve-canisters.js";
-import { prepareMigrationArgs } from "../helpers/migrations.js";
+import { filterCanisters, resolveCanisterConfigs, } from "../helpers/resolve-canisters.js";
+import { BUILD_MANAGED_FLAGS, prepareMocArgs } from "../helpers/moc-args.js";
 import { getWasmBindings } from "../wasm.js";
-import { getGlobalMocArgs, readConfig, resolveConfigPath } from "../mops.js";
-import { sourcesArgs } from "./sources.js";
+import { readConfig, resolveConfigPath } from "../mops.js";
 import { toolchain } from "./toolchain/index.js";
 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, override) {
+    if (override) {
+        return override;
+    }
+    return config.build?.outputDir
+        ? resolveConfigPath(config.build.outputDir)
+        : DEFAULT_BUILD_OUTPUT_DIR;
+}
 export async function build(canisterNames, options) {
     if (canisterNames?.length === 0) {
         cliError("No canisters specified to 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) {
@@ -33,11 +41,6 @@ export async function build(canisterNames, options) {
     const filteredCanisters = filterCanisters(canisters, canisterNames);
     for (let [canisterName, canister] of Object.entries(filteredCanisters)) {
         console.log(chalk.blue("build canister"), chalk.bold(canisterName));
-        let motokoPath = canister.main;
-        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`);
         // per-canister lock to prevent parallel builds of the same canister from clobbering output files
@@ -63,7 +66,13 @@ export async function build(canisterNames, options) {
             catch { }
         };
         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",
@@ -71,12 +80,9 @@ export async function build(canisterNames, options) {
                 "--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";
             if (isPublicCandid) {
@@ -151,7 +157,7 @@ export async function build(canisterNames, options) {
             }
         }
         finally {
-            await migration.cleanup();
+            await prepared.cleanup();
             process.removeListener("exit", exitCleanup);
             try {
                 await release?.();
@@ -161,35 +167,3 @@ export async function build(canisterNames, options) {
     }
     console.log(chalk.green(`\n✓ Built ${Object.keys(filteredCanisters).length} canister${Object.keys(filteredCanisters).length === 1 ? "" : "s"} successfully`));
 }
-const managedFlags = {
-    "-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, canister, canisterName, extraArgs) {
-    const args = [];
-    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();
-    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/dist/commands/check-stable.d.ts

@@ -2,6 +2,8 @@ import { CanisterConfig } from "../types.js";
 export interface CheckStableOptions {
     verbose: boolean;
     extraArgs: string[];
+    /** Commander `--no-check-limit`: false ignores [migrations].check-limit. */
+    checkLimit: boolean;
 }
 export declare function resolveStablePath(canister: CanisterConfig, canisterName: string, options?: {
     required?: boolean;

package/dist/commands/check-stable.js

@@ -52,7 +52,7 @@ export async function checkStable(args, options = {}) {
             cliError(`No main file specified for canister '${name}' in mops.toml`);
         }
         validateCanisterArgs(canister, name, config);
-        const migration = await prepareMigrationArgs(canister.migrations, name, "check", options.verbose);
+        const migration = await prepareMigrationArgs(canister.migrations, name, "check", options.verbose, options.checkLimit === false);
         try {
             await runStableCheck({
                 oldFile,
@@ -85,7 +85,7 @@ export async function checkStable(args, options = {}) {
         if (!stablePath) {
             continue;
         }
-        const migration = await prepareMigrationArgs(canister.migrations, name, "check", options.verbose);
+        const migration = await prepareMigrationArgs(canister.migrations, name, "check", options.verbose, options.checkLimit === false);
         try {
             await runStableCheck({
                 oldFile: stablePath,

package/dist/commands/check.d.ts

@@ -2,5 +2,7 @@ export interface CheckOptions {
     verbose: boolean;
     fix: boolean;
     extraArgs: string[];
+    /** Commander `--no-check-limit`: false ignores [migrations].check-limit. */
+    checkLimit: boolean;
 }
 export declare function check(args: string[], options?: Partial<CheckOptions>): Promise<void>;

package/dist/commands/check.js

@@ -83,6 +83,7 @@ async function checkImpl(args, options = {}) {
             fix: options.fix,
             rules: lintRules,
             files: lintFiles,
+            noCheckLimit: options.checkLimit === false,
         });
     }
 }
@@ -97,7 +98,7 @@ async function checkCanisters(config, canisters, options) {
         }
         validateCanisterArgs(canister, canisterName, config);
         const motokoPath = resolveConfigPath(canister.main);
-        const migration = await prepareMigrationArgs(canister.migrations, canisterName, "check", options.verbose);
+        const migration = await prepareMigrationArgs(canister.migrations, canisterName, "check", options.verbose, options.checkLimit === false);
         try {
             const mocArgs = [
                 "--check",
@@ -171,26 +172,24 @@ async function checkFiles(config, files, options) {
         const fixResult = await autofixMotoko(mocPath, files, mocArgs);
         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)));
-    }
-    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}`));
+        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}` : ""}`);
+        }
     }
 }

package/dist/commands/deployed.d.ts

@@ -0,0 +1,10 @@
+export declare const DEFAULT_DEPLOYED_DIR = "deployed";
+export interface DeployedOptions {
+    buildDir?: string;
+    dir?: string;
+}
+export interface DeployedInitOptions {
+    dir?: string;
+}
+export declare function deployed(canisterNames: string[] | undefined, options?: DeployedOptions): Promise<void>;
+export declare function deployedInit(canisterNames: string[] | undefined, options?: DeployedInitOptions): Promise<void>;

package/dist/commands/deployed.js

@@ -0,0 +1,97 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { copyFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import { cliError } from "../error.js";
+import { filterCanisters, resolveCanisterConfigs, } from "../helpers/resolve-canisters.js";
+import { getRootDir, readConfig, resolveConfigPath, writeConfig, } from "../mops.js";
+import { resolveBuildOutputDir } from "./build.js";
+export const DEFAULT_DEPLOYED_DIR = "deployed";
+const EMPTY_ACTOR_MOST = "// Version: 1.0.0\nactor { };\n";
+// `[deployed].dir` and CLI overrides are tracked in two forms:
+//   - `config`: relative to mops.toml, used for display + writing into mops.toml
+//   - `resolved`: relative to cwd, used for fs operations
+function resolveDeployedDir(config, override) {
+    if (override) {
+        const configRel = path.relative(getRootDir(), path.resolve(override)) || ".";
+        return { config: configRel, resolved: override };
+    }
+    const configured = config.deployed?.dir ?? DEFAULT_DEPLOYED_DIR;
+    return { config: configured, resolved: resolveConfigPath(configured) };
+}
+function selectCanisters(canisterNames, config) {
+    if (canisterNames?.length === 0) {
+        cliError("No canisters specified");
+    }
+    const canisters = resolveCanisterConfigs(config);
+    if (!Object.keys(canisters).length) {
+        cliError(`No Motoko canisters found in mops.toml configuration`);
+    }
+    return filterCanisters(canisters, canisterNames);
+}
+function warnIfStablePathDiverges(name, stablePath, destMostRel) {
+    if (path.resolve(resolveConfigPath(stablePath)) ===
+        path.resolve(resolveConfigPath(destMostRel))) {
+        return;
+    }
+    console.warn(chalk.yellow(`WARN: [canisters.${name}.check-stable].path = "${stablePath}" ` +
+        `does not match where \`mops deployed\` writes ("${destMostRel}"). ` +
+        `\`mops check-stable\` won't see updates from \`mops deployed\`.`));
+}
+export async function deployed(canisterNames, options = {}) {
+    const config = readConfig();
+    const filtered = selectCanisters(canisterNames, config);
+    const buildDir = resolveBuildOutputDir(config, options.buildDir);
+    const deployedDir = resolveDeployedDir(config, options.dir);
+    mkdirSync(deployedDir.resolved, { recursive: true });
+    for (const [name, canister] of Object.entries(filtered)) {
+        const sourceMost = path.join(buildDir, `${name}.most`);
+        const destMostRel = path.join(deployedDir.config, `${name}.most`);
+        const destMost = path.join(deployedDir.resolved, `${name}.most`);
+        if (!existsSync(sourceMost)) {
+            cliError(`No built .most at ${sourceMost}. Run \`mops build ${name}\` first.`);
+        }
+        await copyFile(sourceMost, destMost);
+        console.log(chalk.green(`✓ ${sourceMost} → ${destMost}`));
+        const stablePath = canister["check-stable"]?.path;
+        if (stablePath) {
+            warnIfStablePathDiverges(name, stablePath, destMostRel);
+        }
+    }
+}
+export async function deployedInit(canisterNames, options = {}) {
+    const config = readConfig();
+    const filtered = selectCanisters(canisterNames, config);
+    const deployedDir = resolveDeployedDir(config, options.dir);
+    mkdirSync(deployedDir.resolved, { recursive: true });
+    let configChanged = false;
+    for (const [name, canister] of Object.entries(filtered)) {
+        const destMostRel = path.join(deployedDir.config, `${name}.most`);
+        const destMost = path.join(deployedDir.resolved, `${name}.most`);
+        if (!existsSync(destMost)) {
+            await writeFile(destMost, EMPTY_ACTOR_MOST);
+            console.log(chalk.green(`✓ Created baseline ${destMost}`));
+        }
+        const stablePath = canister["check-stable"]?.path;
+        if (!stablePath) {
+            const entry = config.canisters?.[name];
+            if (typeof entry === "string") {
+                config.canisters[name] = {
+                    main: entry,
+                    "check-stable": { path: destMostRel },
+                };
+            }
+            else if (entry) {
+                entry["check-stable"] = { path: destMostRel };
+            }
+            configChanged = true;
+            console.log(chalk.green(`✓ Set [canisters.${name}.check-stable].path = "${destMostRel}"`));
+        }
+        else {
+            warnIfStablePathDiverges(name, stablePath, destMostRel);
+        }
+    }
+    if (configChanged) {
+        writeConfig(config);
+    }
+}

package/dist/commands/generate.d.ts

@@ -0,0 +1,6 @@
+export interface GenerateCandidOptions {
+    output?: string;
+    verbose?: boolean;
+    extraArgs?: string[];
+}
+export declare function generateCandid(canisterNames: string[] | undefined, options: GenerateCandidOptions): Promise<void>;

package/dist/commands/generate.js

@@ -0,0 +1,124 @@
+import chalk from "chalk";
+import { execa } from "execa";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { cliError } from "../error.js";
+import { filterCanisters, resolveCanisterConfigs, } from "../helpers/resolve-canisters.js";
+import { GENERATE_CANDID_MANAGED_FLAGS, prepareMocArgs, } from "../helpers/moc-args.js";
+import { getRootDir, readConfig, resolveConfigPath, writeConfig, } from "../mops.js";
+import { toolchain } from "./toolchain/index.js";
+export async function generateCandid(canisterNames, options) {
+    if (canisterNames?.length === 0) {
+        cliError("No canisters specified");
+    }
+    const config = readConfig();
+    const canisters = resolveCanisterConfigs(config);
+    if (!Object.keys(canisters).length) {
+        cliError("No Motoko canisters found in mops.toml configuration");
+    }
+    const filtered = filterCanisters(canisters, canisterNames);
+    const filteredEntries = Object.entries(filtered);
+    if (options.output && filteredEntries.length > 1) {
+        cliError("--output / -o is only supported when generating for a single canister");
+    }
+    const mocPath = await toolchain.bin("moc", { fallback: true });
+    const rootDir = getRootDir();
+    let configChanged = false;
+    for (const [canisterName, canister] of filteredEntries) {
+        const dest = resolveDestination(canisterName, canister, canisters, options.output, rootDir);
+        console.log(chalk.blue("generate candid"), chalk.bold(canisterName), chalk.gray(`→ ${dest.fsPath}`));
+        const prepared = await prepareMocArgs(config, canister, canisterName, {
+            mode: "build",
+            managedFlags: GENERATE_CANDID_MANAGED_FLAGS,
+            commandName: "mops generate candid",
+            verbose: options.verbose,
+            extraArgs: options.extraArgs,
+        });
+        try {
+            await mkdir(path.dirname(dest.fsPath), { recursive: true });
+            const args = [
+                "--idl",
+                "-o",
+                dest.fsPath,
+                prepared.motokoPath,
+                ...prepared.args,
+            ];
+            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("Output:"));
+                        console.error(result.stdout);
+                    }
+                }
+                cliError(`Failed to generate Candid for canister ${canisterName} (exit code: ${result.exitCode})`);
+            }
+            if (dest.configPath !== null) {
+                const c = (config.canisters ??= {});
+                const existing = c[canisterName];
+                const obj = typeof existing === "string"
+                    ? { main: existing }
+                    : { ...(existing ?? {}) };
+                obj.candid = dest.configPath;
+                c[canisterName] = obj;
+                configChanged = true;
+            }
+        }
+        finally {
+            await prepared.cleanup();
+        }
+    }
+    if (configChanged) {
+        writeConfig(config);
+    }
+    console.log(chalk.green(`\n✓ Generated Candid for ${filteredEntries.length} canister${filteredEntries.length === 1 ? "" : "s"}`));
+}
+function resolveDestination(canisterName, canister, allCanisters, outputFlag, rootDir) {
+    if (!canister.main) {
+        cliError(`No main file is specified for canister ${canisterName}`);
+    }
+    let fsPath;
+    let configPath;
+    if (outputFlag) {
+        fsPath = outputFlag;
+        configPath = null;
+        const outAbs = path.resolve(fsPath);
+        for (const [otherName, other] of Object.entries(allCanisters)) {
+            if (otherName === canisterName || !other.candid) {
+                continue;
+            }
+            if (path.resolve(rootDir, other.candid) === outAbs) {
+                console.warn(chalk.yellow(`Warning: --output path collides with [canisters.${otherName}].candid (${other.candid}). Sharing a .did between canisters is almost always a mistake.`));
+            }
+        }
+    }
+    else if (canister.candid) {
+        fsPath = resolveConfigPath(canister.candid);
+        configPath = null;
+    }
+    else {
+        // Default: <dirname(main)>/<canisterName>.did, forward slashes for the toml value
+        const mainDir = path.dirname(canister.main).replace(/\\/g, "/");
+        const projectRel = mainDir === "." || mainDir === ""
+            ? `${canisterName}.did`
+            : `${mainDir}/${canisterName}.did`;
+        fsPath = resolveConfigPath(projectRel);
+        configPath = projectRel;
+    }
+    const absPath = path.resolve(fsPath);
+    const dotMopsDir = path.resolve(rootDir, ".mops");
+    if (absPath === dotMopsDir || absPath.startsWith(dotMopsDir + path.sep)) {
+        cliError(`Refusing to write Candid file inside .mops/ (private build cache): ${fsPath}\n` +
+            "Choose a path outside .mops/ — it should be committable and readable by downstream tooling.");
+    }
+    return { fsPath, configPath };
+}

package/dist/commands/lint.d.ts

@@ -6,5 +6,7 @@ export interface LintOptions {
     rules?: string[];
     files?: string[];
     extraArgs: string[];
+    /** Commander `--no-check-limit`: lint the full migration chain. */
+    noCheckLimit?: boolean;
 }
 export declare function lint(filter: string | undefined, options: Partial<LintOptions>): Promise<void>;

package/dist/commands/lint.js

@@ -122,7 +122,7 @@ async function lintImpl(filter, options) {
         ? await toolchain.bin("lintoko")
         : "lintoko";
     const isExplicit = !!filter || !!(options.files && options.files.length > 0);
-    const trimmedMigrations = isExplicit
+    const trimmedMigrations = isExplicit || options.noCheckLimit
         ? new Set()
         : getTrimmedMigrationFiles(config);
     let filesToLint;

package/dist/helpers/autofix-motoko.d.ts

@@ -1,5 +1,7 @@
 interface MocSpan {
     file: string;
+    byte_start?: number | null;
+    byte_end?: number | null;
     line_start: number;
     column_start: number;
     line_end: number;