ic-mops 1.0.1 → 1.1.0

package/dist/commands/install/install-local-dep.d.ts

@@ -1,6 +1,7 @@
 type InstallLocalDepOptions = {
     verbose?: boolean;
     silent?: boolean;
+    ignoreTransitive?: boolean;
 };
-export declare function installLocalDep(pkg: string, pkgPath?: string, { verbose, silent }?: InstallLocalDepOptions): Promise<boolean>;
+export declare function installLocalDep(pkg: string, pkgPath?: string, { verbose, silent, ignoreTransitive }?: InstallLocalDepOptions): Promise<boolean>;
 export {};

package/dist/commands/install/install-local-dep.js

@@ -5,7 +5,7 @@ import { getRootDir, readConfig } from '../../mops.js';
 import { installDeps } from './install-deps.js';
 // skip install and just find non-local dependencies to install
 // pkgPath should be relative to the current root dir or absolute
-export async function installLocalDep(pkg, pkgPath = '', { verbose, silent } = {}) {
+export async function installLocalDep(pkg, pkgPath = '', { verbose, silent, ignoreTransitive } = {}) {
     if (!silent) {
         let logUpdate = createLogUpdate(process.stdout, { showCursor: true });
         logUpdate(`Local dependency ${pkg} = "${pkgPath}"`);
@@ -17,7 +17,12 @@ export async function installLocalDep(pkg, pkgPath = '', { verbose, silent } = {
         }
     }
     // install dependencies
-    let dir = path.resolve(getRootDir(), pkgPath);
-    let config = readConfig(path.join(dir, 'mops.toml'));
-    return installDeps(Object.values(config.dependencies || {}), { silent, verbose }, pkgPath);
+    if (!ignoreTransitive) {
+        let dir = path.resolve(getRootDir(), pkgPath);
+        let config = readConfig(path.join(dir, 'mops.toml'));
+        return installDeps(Object.values(config.dependencies || {}), { silent, verbose }, pkgPath);
+    }
+    else {
+        return true;
+    }
 }

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

@@ -3,6 +3,7 @@ type InstallMopsDepOptions = {
     silent?: boolean;
     dep?: boolean;
     threads?: number;
+    ignoreTransitive?: boolean;
 };
-export declare function installMopsDep(pkg: string, version?: string, { verbose, silent, dep, threads }?: InstallMopsDepOptions): Promise<boolean>;
+export declare function installMopsDep(pkg: string, version?: string, { verbose, silent, dep, threads, ignoreTransitive }?: InstallMopsDepOptions): Promise<boolean>;
 export {};

package/dist/commands/install/install-mops-dep.js

@@ -13,7 +13,7 @@ import { getDepCacheDir, getMopsDepCacheName, isDepCached } from '../../cache.js
 import { downloadFile, getPackageFilesInfo } from '../../api/downloadPackageFiles.js';
 import { installDeps } from './install-deps.js';
 import { getDepName } from '../../helpers/get-dep-name.js';
-export async function installMopsDep(pkg, version = '', { verbose, silent, dep, threads } = {}) {
+export async function installMopsDep(pkg, version = '', { verbose, silent, dep, threads, ignoreTransitive } = {}) {
     threads = threads || 12;
     let depName = getDepName(pkg);
     if (!checkConfigFile()) {
@@ -90,10 +90,12 @@ export async function installMopsDep(pkg, version = '', { verbose, silent, dep,
         logUpdate.clear();
     }
     // install dependencies
-    let config = readConfig(path.join(cacheDir, 'mops.toml'));
-    let res = await installDeps(Object.values(config.dependencies || {}), { silent, verbose });
-    if (!res) {
-        return false;
+    if (!ignoreTransitive) {
+        let config = readConfig(path.join(cacheDir, 'mops.toml'));
+        let res = await installDeps(Object.values(config.dependencies || {}), { silent, verbose });
+        if (!res) {
+            return false;
+        }
     }
     return true;
 }

package/dist/commands/replica.d.ts

@@ -25,12 +25,12 @@ export declare class Replica {
     start({ type, dir, verbose, silent }?: StartOptions): Promise<void>;
     _attachCanisterLogHandler(proc: ChildProcessWithoutNullStreams): void;
     stop(sigint?: boolean): Promise<void>;
-    deploy(name: string, wasm: string, idlFactory: IDL.InterfaceFactory, cwd?: string): Promise<{
+    deploy(name: string, wasm: string, idlFactory: IDL.InterfaceFactory, cwd?: string, signal?: AbortSignal): Promise<{
         cwd: string;
         canisterId: string;
         actor: any;
         stream: PassThrough;
-    }>;
+    } | undefined>;
     getActor(name: string): unknown;
     getCanister(name: string): {
         cwd: string;

package/dist/commands/replica.js

@@ -3,6 +3,7 @@ import { execSync, spawn } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
 import { PassThrough } from 'node:stream';
+import { spawn as spawnAsync } from 'promisify-child-process';
 import { Actor, HttpAgent } from '@dfinity/agent';
 import { PocketIc, PocketIcServer } from 'pic-ic';
 import { readConfig } from '../mops.js';
@@ -97,7 +98,7 @@ export class Replica {
             await this.pocketIcServer.stop();
         }
     }
-    async deploy(name, wasm, idlFactory, cwd = process.cwd()) {
+    async deploy(name, wasm, idlFactory, cwd = process.cwd(), signal) {
         if (this.type === 'dfx') {
             // prepare dfx.json for current canister
             let dfxJson = path.join(this.dir, 'dfx.json');
@@ -111,8 +112,24 @@ export class Replica {
             }
             fs.mkdirSync(this.dir, { recursive: true });
             fs.writeFileSync(dfxJson, JSON.stringify(newDfxJsonData, null, 2));
-            execSync(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, { cwd: this.dir, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
-            execSync(`dfx ledger fabricate-cycles --canister ${name} --t 100`, { cwd: this.dir, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] });
+            await spawnAsync('dfx', ['deploy', name, '--mode', 'reinstall', '--yes', '--identity', 'anonymous'], { cwd: this.dir, signal, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] }).catch((error) => {
+                if (error.code === 'ABORT_ERR') {
+                    return { stderr: '' };
+                }
+                throw error;
+            });
+            if (signal?.aborted) {
+                return;
+            }
+            await spawnAsync('dfx', ['ledger', 'fabricate-cycles', '--canister', name, '--t', '100'], { cwd: this.dir, signal, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe'] }).catch((error) => {
+                if (error.code === 'ABORT_ERR') {
+                    return { stderr: '' };
+                }
+                throw error;
+            });
+            if (signal?.aborted) {
+                return;
+            }
             let canisterId = execSync(`dfx canister id ${name}`, { cwd: this.dir }).toString().trim();
             let actor = Actor.createActor(idlFactory, {
                 agent: await HttpAgent.create({
@@ -134,7 +151,13 @@ export class Replica {
                 idlFactory,
                 wasm,
             });
+            if (signal?.aborted) {
+                return;
+            }
             await this.pocketIc.addCycles(canisterId, 1_000_000_000_000);
+            if (signal?.aborted) {
+                return;
+            }
             this.canisters[name] = {
                 cwd,
                 canisterId: canisterId.toText(),

package/dist/commands/sources.d.ts

@@ -1,4 +1,4 @@
 export declare function sources({ conflicts, cwd }?: {
     conflicts?: "ignore" | "error" | "warning" | undefined;
     cwd?: string | undefined;
-}): Promise<(string | undefined)[]>;
+}): Promise<string[]>;

package/dist/commands/sources.js

@@ -38,5 +38,5 @@ export async function sources({ conflicts = 'ignore', cwd = process.cwd() } = {}
             pkgBaseDir = pkgDir;
         }
         return `--package ${name} ${pkgBaseDir}`;
-    });
+    }).filter(x => x != null);
 }

package/dist/commands/sync.js

@@ -1,4 +1,3 @@
-import process from 'node:process';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
 import { globSync } from 'glob';
@@ -7,6 +6,7 @@ import { checkConfigFile, getRootDir, readConfig } from '../mops.js';
 import { add } from './add.js';
 import { remove } from './remove.js';
 import { checkIntegrity } from '../integrity.js';
+import { getMocPath } from '../helpers/get-moc-path.js';
 export async function sync({ lock } = {}) {
     if (!checkConfigFile()) {
         return;
@@ -35,24 +35,9 @@ let ignore = [
     '**/.git/**',
     '**/.mops/**',
 ];
-let mocPath = '';
-function getMocPath() {
-    if (!mocPath) {
-        mocPath = process.env.DFX_MOC_PATH || '';
-    }
-    if (!mocPath) {
-        try {
-            mocPath = execSync('dfx cache show').toString().trim() + '/moc';
-        }
-        catch { }
-    }
-    if (!mocPath) {
-        mocPath = 'moc';
-    }
-    return mocPath;
-}
 async function getUsedPackages() {
     let rootDir = getRootDir();
+    let mocPath = getMocPath();
     let files = globSync('**/*.mo', {
         cwd: rootDir,
         nocase: true,
@@ -60,7 +45,7 @@ async function getUsedPackages() {
     });
     let packages = new Set;
     for (let file of files) {
-        let deps = execSync(`${getMocPath()} --print-deps ${path.join(rootDir, file)}`).toString().trim().split('\n');
+        let deps = execSync(`${mocPath} --print-deps ${path.join(rootDir, file)}`).toString().trim().split('\n');
         for (let dep of deps) {
             if (dep.startsWith('mo:') && !dep.startsWith('mo:prim') && !dep.startsWith('mo:⛔')) {
                 packages.add(dep.replace(/^mo:([^/]+).*$/, '$1'));

package/dist/commands/test/mmf1.d.ts

@@ -18,6 +18,7 @@ export declare class MMF1 {
     constructor(strategy: Strategy, file: string);
     _log(type: MessageType, ...args: string[]): void;
     flush(messageType?: MessageType): void;
+    getErrorMessages(): string[];
     parseLine(line: string): void;
     _testStart(name: string): void;
     _testEnd(name: string): void;

package/dist/commands/test/mmf1.js

@@ -39,6 +39,9 @@ export class MMF1 {
         }
         this.output = [];
     }
+    getErrorMessages() {
+        return this.output.filter(out => out.type === 'fail').map(out => out.message);
+    }
     parseLine(line) {
         if (line.startsWith('mops:1:start ')) {
             this._testStart(line.split('mops:1:start ')[1] || '');

package/dist/commands/test/reporters/silent-reporter.d.ts

@@ -2,13 +2,18 @@ import { MMF1 } from '../mmf1.js';
 import { Reporter } from './reporter.js';
 import { TestMode } from '../../../types.js';
 export declare class SilentReporter implements Reporter {
+    total: number;
     passed: number;
     failed: number;
     skipped: number;
     passedFiles: number;
     failedFiles: number;
     passedNamesFlat: string[];
-    addFiles(_files: string[]): void;
+    flushOnError: boolean;
+    errorOutput: string;
+    onProgress: () => void;
+    constructor(flushOnError?: boolean, onProgress?: () => void);
+    addFiles(files: string[]): void;
     addRun(file: string, mmf: MMF1, state: Promise<void>, _mode: TestMode): void;
     done(): boolean;
 }

package/dist/commands/test/reporters/silent-reporter.js

@@ -1,15 +1,23 @@
 import chalk from 'chalk';
 import { absToRel } from '../utils.js';
 export class SilentReporter {
-    constructor() {
+    constructor(flushOnError = true, onProgress = () => { }) {
+        this.total = 0;
         this.passed = 0;
         this.failed = 0;
         this.skipped = 0;
         this.passedFiles = 0;
         this.failedFiles = 0;
         this.passedNamesFlat = [];
+        this.flushOnError = true;
+        this.errorOutput = '';
+        this.onProgress = () => { };
+        this.flushOnError = flushOnError;
+        this.onProgress = onProgress;
+    }
+    addFiles(files) {
+        this.total = files.length;
     }
-    addFiles(_files) { }
     addRun(file, mmf, state, _mode) {
         state.then(() => {
             this.passed += mmf.passed;
@@ -23,10 +31,15 @@ export class SilentReporter {
             this.passedFiles += Number(mmf.failed === 0);
             this.failedFiles += Number(mmf.failed !== 0);
             if (mmf.failed) {
-                console.log(chalk.red('✖'), absToRel(file));
-                mmf.flush('fail');
-                console.log('-'.repeat(50));
+                let output = `${chalk.red('✖')} ${absToRel(file)}\n${mmf.getErrorMessages().join('\n')}\n${'-'.repeat(50)}`;
+                if (this.flushOnError) {
+                    console.log(output);
+                }
+                else {
+                    this.errorOutput = `${this.errorOutput}\n${output}`.trim();
+                }
             }
+            this.onProgress();
         });
     }
     done() {

package/dist/commands/test/test.d.ts

@@ -9,5 +9,5 @@ type TestOptions = {
     replica: ReplicaName;
 };
 export declare function test(filter?: string, options?: Partial<TestOptions>): Promise<void>;
-export declare function testWithReporter(reporterName: ReporterName | Reporter | undefined, filter: string | undefined, defaultMode: TestMode | undefined, replicaType: ReplicaName, watch?: boolean): Promise<boolean>;
+export declare function testWithReporter(reporterName: ReporterName | Reporter | undefined, filter: string | undefined, defaultMode: TestMode | undefined, replicaType: ReplicaName, watch?: boolean, signal?: AbortSignal): Promise<boolean>;
 export {};

package/dist/commands/test/test.js

@@ -59,13 +59,22 @@ export async function test(filter = '', options = {}) {
                     process.exit(0);
                 });
             }
+            else {
+                process.exit(0);
+            }
         });
         // todo: run only changed for *.test.mo?
         // todo: run all for *.mo?
+        let curRun = Promise.resolve(true);
+        let controller = new AbortController();
         let run = debounce(async () => {
+            controller.abort();
+            await curRun;
             console.clear();
             process.stdout.write('\x1Bc');
-            await runAll(options.reporter, filter, options.mode, replicaType, true);
+            controller = new AbortController();
+            curRun = runAll(options.reporter, filter, options.mode, replicaType, true, controller.signal);
+            await curRun;
             console.log('-'.repeat(50));
             console.log('Waiting for file changes...');
             console.log(chalk.gray((`Press ${chalk.gray('Ctrl+C')} to exit.`)));
@@ -91,11 +100,11 @@ export async function test(filter = '', options = {}) {
 }
 let mocPath = '';
 let wasmtimePath = '';
-async function runAll(reporterName, filter = '', mode = 'interpreter', replicaType, watch = false) {
-    let done = await testWithReporter(reporterName, filter, mode, replicaType, watch);
+async function runAll(reporterName, filter = '', mode = 'interpreter', replicaType, watch = false, signal) {
+    let done = await testWithReporter(reporterName, filter, mode, replicaType, watch, signal);
     return done;
 }
-export async function testWithReporter(reporterName, filter = '', defaultMode = 'interpreter', replicaType, watch = false) {
+export async function testWithReporter(reporterName, filter = '', defaultMode = 'interpreter', replicaType, watch = false, signal) {
     let rootDir = getRootDir();
     let files = [];
     let libFiles = globSync('**/test?(s)/lib.mo', globConfig);
@@ -149,6 +158,9 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
     replica.dir = testTempDir;
     fs.mkdirSync(testTempDir, { recursive: true });
     await parallel(os.cpus().length, files, async (file) => {
+        if (signal?.aborted) {
+            return;
+        }
         let mmf = new MMF1('store', absToRel(file));
         // mode overrides
         let lines = fs.readFileSync(file, 'utf8').split('\n');
@@ -175,14 +187,26 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
             let mocArgs = ['--hide-warnings', '--error-detail=2', ...sourcesArr.join(' ').split(' '), file].filter(x => x);
             // interpret
             if (mode === 'interpreter') {
-                let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs]);
+                let proc = spawn(mocPath, ['-r', '-ref-system-api', ...mocArgs], { signal });
+                proc.addListener('error', (error) => {
+                    if (error?.code === 'ABORT_ERR') {
+                        return;
+                    }
+                    throw error;
+                });
                 pipeMMF(proc, mmf).then(resolve);
             }
             // build and run wasm
             else if (mode === 'wasi') {
                 let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
                 // build
-                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, '-wasi-system-api', ...mocArgs]);
+                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, '-wasi-system-api', ...mocArgs], { signal });
+                buildProc.addListener('error', (error) => {
+                    if (error?.code === 'ABORT_ERR') {
+                        return;
+                    }
+                    throw error;
+                });
                 pipeMMF(buildProc, mmf).then(async () => {
                     if (mmf.failed > 0) {
                         return;
@@ -204,7 +228,13 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                         console.error(chalk.red('Minimum wasmtime version is 14.0.0. Please update wasmtime to the latest version'));
                         process.exit(1);
                     }
-                    let proc = spawn(wasmtimePath, wasmtimeArgs);
+                    let proc = spawn(wasmtimePath, wasmtimeArgs, { signal });
+                    proc.addListener('error', (error) => {
+                        if (error?.code === 'ABORT_ERR') {
+                            return;
+                        }
+                        throw error;
+                    });
                     await pipeMMF(proc, mmf);
                 }).finally(() => {
                     fs.rmSync(wasmFile, { force: true });
@@ -215,18 +245,30 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                 // mmf.strategy = 'print'; // because we run replica tests one-by-one
                 let wasmFile = `${path.join(testTempDir, path.parse(file).name)}.wasm`;
                 // build
-                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs]);
+                let buildProc = spawn(mocPath, [`-o=${wasmFile}`, ...mocArgs], { signal });
+                buildProc.addListener('error', (error) => {
+                    if (error?.code === 'ABORT_ERR') {
+                        return;
+                    }
+                    throw error;
+                });
                 pipeMMF(buildProc, mmf).then(async () => {
                     if (mmf.failed > 0) {
                         return;
                     }
                     await startReplicaOnce(replica, replicaType);
+                    if (signal?.aborted) {
+                        return;
+                    }
                     let canisterName = path.parse(file).name;
                     let idlFactory = ({ IDL }) => {
                         return IDL.Service({ 'runTests': IDL.Func([], [], []) });
                     };
-                    let { stream } = await replica.deploy(canisterName, wasmFile, idlFactory);
-                    pipeStdoutToMMF(stream, mmf);
+                    let canister = await replica.deploy(canisterName, wasmFile, idlFactory, undefined, signal);
+                    if (signal?.aborted || !canister) {
+                        return;
+                    }
+                    pipeStdoutToMMF(canister.stream, mmf);
                     let actor = await replica.getActor(canisterName);
                     try {
                         if (globalThis.mopsReplicaTestRunning) {
@@ -239,6 +281,9 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                                 }, Math.random() * 1000 | 0);
                             });
                         }
+                        if (signal?.aborted) {
+                            return;
+                        }
                         globalThis.mopsReplicaTestRunning = true;
                         await actor.runTests();
                         globalThis.mopsReplicaTestRunning = false;
@@ -250,10 +295,14 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
                         stderrStream.write(e.message);
                     }
                 }).finally(async () => {
+                    globalThis.mopsReplicaTestRunning = false;
                     fs.rmSync(wasmFile, { force: true });
                 }).then(resolve);
             }
         });
+        if (signal?.aborted) {
+            return;
+        }
         reporter.addRun(file, mmf, promise, mode);
         await promise;
     });
@@ -261,6 +310,9 @@ export async function testWithReporter(reporterName, filter = '', defaultMode =
         await replica.stop();
         fs.rmSync(testTempDir, { recursive: true, force: true });
     }
+    if (signal?.aborted) {
+        return false;
+    }
     return reporter.done();
 }
 function pipeStdoutToMMF(stdout, mmf) {

package/dist/commands/watch/deployer.d.ts

@@ -0,0 +1,24 @@
+import { ErrorChecker } from './error-checker.js';
+import { Generator } from './generator.js';
+export declare class Deployer {
+    verbose: boolean;
+    canisters: Record<string, string>;
+    status: 'pending' | 'running' | 'syntax-error' | 'dfx-error' | 'error' | 'success';
+    errorChecker: ErrorChecker;
+    generator: Generator;
+    success: number;
+    errors: string[];
+    aborted: boolean;
+    controllers: Map<string, AbortController>;
+    currentRun: Promise<any> | undefined;
+    constructor({ verbose, canisters, errorChecker, generator }: {
+        verbose: boolean;
+        canisters: Record<string, string>;
+        errorChecker: ErrorChecker;
+        generator: Generator;
+    });
+    reset(): void;
+    abortCurrent(): Promise<void>;
+    run(onProgress: () => void): Promise<void>;
+    getOutput(): string;
+}

package/dist/commands/watch/deployer.js

@@ -0,0 +1,125 @@
+import chalk from 'chalk';
+import os from 'node:os';
+import { promisify } from 'node:util';
+import { execFile, execSync } from 'node:child_process';
+import { parallel } from '../../parallel.js';
+import { getRootDir } from '../../mops.js';
+export class Deployer {
+    constructor({ verbose, canisters, errorChecker, generator }) {
+        this.verbose = false;
+        this.canisters = {};
+        this.status = 'pending';
+        this.success = 0;
+        this.errors = [];
+        this.aborted = false;
+        this.controllers = new Map();
+        this.verbose = verbose;
+        this.canisters = canisters;
+        this.errorChecker = errorChecker;
+        this.generator = generator;
+    }
+    reset() {
+        this.status = 'pending';
+        this.success = 0;
+        this.errors = [];
+    }
+    async abortCurrent() {
+        this.aborted = true;
+        for (let controller of this.controllers.values()) {
+            controller.abort();
+        }
+        this.controllers.clear();
+        await this.currentRun;
+        this.reset();
+        this.aborted = false;
+    }
+    async run(onProgress) {
+        await this.abortCurrent();
+        if (this.errorChecker.status === 'error') {
+            this.status = 'syntax-error';
+            onProgress();
+            return;
+        }
+        if (Object.keys(this.canisters).length === 0) {
+            this.status = 'success';
+            onProgress();
+            return;
+        }
+        let rootDir = getRootDir();
+        try {
+            execSync('dfx ping', { cwd: rootDir });
+        }
+        catch (error) {
+            this.status = 'dfx-error';
+            onProgress();
+            return;
+        }
+        this.status = 'running';
+        onProgress();
+        // create canisters (sequentially to avoid DFX errors)
+        let resolve;
+        this.currentRun = new Promise((res) => resolve = res);
+        for (let canister of Object.keys(this.canisters)) {
+            let controller = new AbortController();
+            let { signal } = controller;
+            this.controllers.set(canister, controller);
+            await promisify(execFile)('dfx', ['canister', 'create', canister], { cwd: rootDir, signal }).catch((error) => {
+                if (error.code === 'ABORT_ERR') {
+                    return { stderr: '' };
+                }
+                throw error;
+            });
+            this.controllers.delete(canister);
+        }
+        resolve?.();
+        if (this.aborted) {
+            return;
+        }
+        this.currentRun = parallel(os.cpus().length, [...Object.keys(this.canisters)], async (canister) => {
+            let controller = new AbortController();
+            let { signal } = controller;
+            this.controllers.set(canister, controller);
+            // build
+            if (this.generator.status !== 'success' || !this.generator.canisters[canister]) {
+                await promisify(execFile)('dfx', ['build', canister], { cwd: rootDir, signal }).catch((error) => {
+                    if (error.code === 'ABORT_ERR') {
+                        return { stderr: '' };
+                    }
+                    throw error;
+                });
+            }
+            // install
+            await promisify(execFile)('dfx', ['canister', 'install', '--mode=auto', canister], { cwd: rootDir, signal }).catch((error) => {
+                if (error.code === 'ABORT_ERR') {
+                    return { stderr: '' };
+                }
+                throw error;
+            });
+            this.success += 1;
+            this.controllers.delete(canister);
+            onProgress();
+        });
+        await this.currentRun;
+        if (!this.aborted) {
+            this.status = 'success';
+        }
+        onProgress();
+    }
+    getOutput() {
+        let get = (v) => v.toString();
+        let count = (this.status === 'running' ? get : chalk.bold[this.errors.length > 0 ? 'redBright' : 'green'])(this.errors.length || this.success);
+        if (this.status === 'pending') {
+            return `Deploy: ${chalk.gray('(pending)')}`;
+        }
+        if (this.status === 'running') {
+            return `Deploy: ${count}/${Object.keys(this.canisters).length} ${chalk.gray('(running)')}`;
+        }
+        if (this.status === 'syntax-error') {
+            return `Deploy: ${chalk.gray('(errors)')}`;
+        }
+        if (this.status === 'dfx-error') {
+            return `Deploy: ${chalk.gray('(dfx not running)')}`;
+        }
+        return `Deploy: ${count}`;
+    }
+}

package/dist/commands/watch/error-checker.d.ts

@@ -0,0 +1,13 @@
+export declare class ErrorChecker {
+    verbose: boolean;
+    canisters: Record<string, string>;
+    status: 'pending' | 'running' | 'error' | 'success';
+    errors: string[];
+    constructor({ verbose, canisters }: {
+        verbose: boolean;
+        canisters: Record<string, string>;
+    });
+    reset(): void;
+    run(onProgress: () => void): Promise<void>;
+    getOutput(): string;
+}