@capraconsulting/cals-cli 3.13.0 → 3.13.1

package/README.md

@@ -13,26 +13,14 @@ It is recommended to use `npx` over global install to ensure you
 always run the latest version. If you install it globally remember
 to update it before running.
 
-## Building locally
+## Build
 
-Clone this repo.
+Build and verify:
 
-Use NPM to link this repo as a global package:
-
-```bash
-npm install
-npm run build
-npm link
+```sh
+$ make  # or "make build"
 ```
 
-Run the cli from any terminal/folder:
-
-```bash
-cals
-```
-
-Rebuild using `npm run build`.
-
 ## Contributing
 
 This project uses [semantic release](https://semantic-release.gitbook.io/semantic-release/)

package/lib/cals-cli.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import process$2 from 'node:process';
+import * as process$1 from 'node:process';
+import process__default from 'node:process';
 import semver from 'semver';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
@@ -12,7 +13,6 @@ import { performance } from 'node:perf_hooks';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
-import * as process$1 from 'process';
 import keytar from 'keytar';
 import { deprecate } from 'node:util';
 import path from 'node:path';
@@ -26,7 +26,7 @@ import { read } from 'read';
 import { findUp } from 'find-up';
 import { execa } from 'execa';
 
-var version = "3.13.0";
+var version = "3.13.1";
 var engines = {
 	node: ">=22.14.0"
 };
@@ -464,12 +464,12 @@ class GitHubTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "github-token";
     async getToken() {
-        if (process$2.env.CALS_GITHUB_TOKEN) {
-            return process$2.env.CALS_GITHUB_TOKEN;
+        if (process__default.env.CALS_GITHUB_TOKEN) {
+            return process__default.env.CALS_GITHUB_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process$2.stderr.write("No token found. Register using `cals github set-token`\n");
+            process__default.stderr.write("No token found. Register using `cals github set-token`\n");
             return undefined;
         }
         return result;
@@ -1035,12 +1035,12 @@ class SnykTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "snyk-token";
     async getToken() {
-        if (process$2.env.CALS_SNYK_TOKEN) {
-            return process$2.env.CALS_SNYK_TOKEN;
+        if (process__default.env.CALS_SNYK_TOKEN) {
+            return process__default.env.CALS_SNYK_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process$2.stderr.write("No token found. Register using `cals snyk set-token`\n");
+            process__default.stderr.write("No token found. Register using `cals snyk set-token`\n");
             return undefined;
         }
         return result;
@@ -1098,7 +1098,7 @@ class SnykService {
                 agent: this.config.agent,
             });
             if (response.status === 401) {
-                process$2.stderr.write("Unauthorized - removing token\n");
+                process__default.stderr.write("Unauthorized - removing token\n");
                 await this.tokenProvider.markInvalid();
             }
             if (!response.ok) {
@@ -1227,7 +1227,7 @@ class CacheProvider {
 }
 
 class Config {
-    cwd = path.resolve(process$2.cwd());
+    cwd = path.resolve(process__default.cwd());
     configFile = path.join(os.homedir(), ".cals-config.json");
     cacheDir = cachedir("cals-cli");
     agent = new https.Agent({
@@ -1285,8 +1285,8 @@ class Reporter {
         this.nonInteractive = !!opts.nonInteractive;
         this.isVerbose = !!opts.verbose;
     }
-    stdout = process$2.stdout;
-    stderr = process$2.stderr;
+    stdout = process__default.stdout;
+    stderr = process__default.stderr;
     nonInteractive;
     isVerbose;
     format = chalk;
@@ -1626,7 +1626,7 @@ const command$f = {
         .demandCommand()
         .usage("cals definition"),
     handler: () => {
-        yargs(hideBin(process$2.argv)).showHelp();
+        yargs(hideBin(process__default.argv)).showHelp();
     },
 };
 
@@ -2209,7 +2209,7 @@ const command$b = {
 
 async function generateCloneCommands({ reporter, config, github, org, ...opt }) {
     if (!opt.listGroups && !opt.all && opt.group === undefined) {
-        yargs(hideBin(process$2.argv)).showHelp();
+        yargs(hideBin(process__default.argv)).showHelp();
         return;
     }
     const repos = await github.getOrgRepoList({ org });
@@ -2233,7 +2233,7 @@ async function generateCloneCommands({ reporter, config, github, org, ...opt })
             .forEach((repo) => {
             // The output of this is used to pipe into e.g. bash.
             // We cannot use reporter.log as it adds additional characters.
-            process$2.stdout.write(sprintf('[ ! -e "%s" ] && git clone %s\n', repo.name, repo.sshUrl));
+            process__default.stdout.write(sprintf('[ ! -e "%s" ] && git clone %s\n', repo.name, repo.sshUrl));
         });
     });
 }
@@ -2377,7 +2377,7 @@ async function listRepos({ reporter, github, includeArchived, name = undefined,
     }
     // All CSV output is done using direct stdout to avoid extra chars.
     if (csv) {
-        process$2.stdout.write("reponame,group\n");
+        process__default.stdout.write("reponame,group\n");
     }
     getGroupedRepos(repos).forEach((group) => {
         if (!csv && compact) {
@@ -2390,7 +2390,7 @@ async function listRepos({ reporter, github, includeArchived, name = undefined,
         group.items.forEach((repo) => {
             if (csv) {
                 // We assume we have no repos or group names with a comma in its name.
-                process$2.stdout.write(`${repo.name},${group.name}\n`);
+                process__default.stdout.write(`${repo.name},${group.name}\n`);
                 return;
             }
             if (compact) {
@@ -2954,7 +2954,7 @@ async function sync$1({ reporter, github, cals, rootdir, askClone, askMove, }) {
         for (const it of archivedRepos) {
             reporter.info(`  ${it.actualRelpath}`);
         }
-        const thisDirName = path.basename(process$2.cwd());
+        const thisDirName = path.basename(process__default.cwd());
         const archiveDir = `../${thisDirName}-archive`;
         const hasArchiveDir = fs.existsSync(archiveDir);
         if (hasArchiveDir) {
@@ -3036,7 +3036,7 @@ async function loadCalsManifest(config, reporter) {
     const p = await findUp(CALS_YAML, { cwd: config.cwd });
     if (p === undefined) {
         reporter.error(`File ${CALS_YAML} not found. See help`);
-        process$2.exitCode = 1;
+        process__default.exitCode = 1;
         return null;
     }
     // TODO: Verify file has expected contents.
@@ -3153,7 +3153,7 @@ Notes:
   option to avoid stale cache. The cache can also be cleared with
   the "cals delete-cache" command.`),
     handler: () => {
-        yargs(hideBin(process$2.argv)).showHelp();
+        yargs(hideBin(process__default.argv)).showHelp();
     },
 };
 
@@ -3299,17 +3299,17 @@ Notes:
   and provide a link to generate one:
   $ cals snyk set-token`),
     handler: () => {
-        yargs(hideBin(process$2.argv)).showHelp();
+        yargs(hideBin(process__default.argv)).showHelp();
     },
 };
 
 async function main() {
-    if (!semver.satisfies(process$2.version, engines.node)) {
-        console.error(`Required node version ${engines.node} not satisfied with current version ${process$2.version}.`);
-        process$2.exit(1);
+    if (!semver.satisfies(process__default.version, engines.node)) {
+        console.error(`Required node version ${engines.node} not satisfied with current version ${process__default.version}.`);
+        process__default.exit(1);
     }
-    await yargs(hideBin(process$2.argv))
-        .usage(`cals-cli v${version} (build: ${"2026-01-12T15:34:12+0000"})`)
+    await yargs(hideBin(process__default.argv))
+        .usage(`cals-cli v${version} (build: ${"2026-01-22T15:26:47+0000"})`)
         .scriptName("cals")
         .locale("en")
         .help("help")

package/lib/index.d.ts

@@ -8,6 +8,5 @@ export declare const VERSION: string;
 export * as definition from "./definition";
 export * as github from "./github";
 export * as snyk from "./snyk";
-export * as sonarCloud from "./sonarcloud";
 export * from "./testing";
 export { CacheProvider, Config, createGitHubService, createReporter, DefinitionFile, GitHubService, Reporter, };

package/lib/index.es.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import process$1 from 'node:process';
+import * as process from 'node:process';
+import process__default from 'node:process';
 import readline from 'node:readline';
 import chalk from 'chalk';
 import 'node:util';
@@ -14,14 +15,13 @@ import { performance } from 'node:perf_hooks';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
-import * as process from 'process';
 import keytar from 'keytar';
 import { strict } from 'node:assert';
 import { Transform } from 'node:stream';
 import { execa } from 'execa';
 import { read } from 'read';
 
-var version = "3.13.0";
+var version = "3.13.1";
 
 class CacheProvider {
     constructor(config) {
@@ -86,8 +86,8 @@ class Reporter {
         this.nonInteractive = !!opts.nonInteractive;
         this.isVerbose = !!opts.verbose;
     }
-    stdout = process$1.stdout;
-    stderr = process$1.stderr;
+    stdout = process__default.stdout;
+    stderr = process__default.stderr;
     nonInteractive;
     isVerbose;
     format = chalk;
@@ -110,7 +110,7 @@ class Reporter {
 }
 
 class Config {
-    cwd = path.resolve(process$1.cwd());
+    cwd = path.resolve(process__default.cwd());
     configFile = path.join(os.homedir(), ".cals-config.json");
     cacheDir = cachedir("cals-cli");
     agent = new https.Agent({
@@ -571,7 +571,7 @@ function getGitHubOrgs(definition) {
     return uniq(githubOrganizations);
 }
 
-var index$3 = /*#__PURE__*/Object.freeze({
+var index$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   DefinitionFile: DefinitionFile,
   getGitHubOrgs: getGitHubOrgs,
@@ -591,12 +591,12 @@ class GitHubTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "github-token";
     async getToken() {
-        if (process$1.env.CALS_GITHUB_TOKEN) {
-            return process$1.env.CALS_GITHUB_TOKEN;
+        if (process__default.env.CALS_GITHUB_TOKEN) {
+            return process__default.env.CALS_GITHUB_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process$1.stderr.write("No token found. Register using `cals github set-token`\n");
+            process__default.stderr.write("No token found. Register using `cals github set-token`\n");
             return undefined;
         }
         return result;
@@ -1113,7 +1113,7 @@ async function createGitHubService(props) {
     });
 }
 
-var index$2 = /*#__PURE__*/Object.freeze({
+var index$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   GitHubService: GitHubService,
   createGitHubService: createGitHubService
@@ -1123,12 +1123,12 @@ class SnykTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "snyk-token";
     async getToken() {
-        if (process$1.env.CALS_SNYK_TOKEN) {
-            return process$1.env.CALS_SNYK_TOKEN;
+        if (process__default.env.CALS_SNYK_TOKEN) {
+            return process__default.env.CALS_SNYK_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process$1.stderr.write("No token found. Register using `cals snyk set-token`\n");
+            process__default.stderr.write("No token found. Register using `cals snyk set-token`\n");
             return undefined;
         }
         return result;
@@ -1186,7 +1186,7 @@ class SnykService {
                 agent: this.config.agent,
             });
             if (response.status === 401) {
-                process$1.stderr.write("Unauthorized - removing token\n");
+                process__default.stderr.write("Unauthorized - removing token\n");
                 await this.tokenProvider.markInvalid();
             }
             if (!response.ok) {
@@ -1261,7 +1261,7 @@ function getGitHubRepoId(repo) {
     return repo ? `${repo.owner}/${repo.name}` : undefined;
 }
 
-var index$1 = /*#__PURE__*/Object.freeze({
+var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
   SnykService: SnykService,
   createSnykService: createSnykService,
@@ -1269,71 +1269,6 @@ var index$1 = /*#__PURE__*/Object.freeze({
   getGitHubRepoId: getGitHubRepoId
 });
 
-class SonarCloudTokenCliProvider {
-    async getToken() {
-        if (process$1.env.CALS_SONARCLOUD_TOKEN) {
-            return Promise.resolve(process$1.env.CALS_SONARCLOUD_TOKEN);
-        }
-        process$1.stderr.write("No environmental variable found. Set variable `CALS_SONARCLOUD_TOKEN` to token value\n");
-        return undefined;
-    }
-    async markInvalid() {
-        await Promise.resolve();
-    }
-}
-
-class SonarCloudService {
-    config;
-    tokenProvider;
-    constructor(props) {
-        this.config = props.config;
-        this.tokenProvider = props.tokenProvider;
-    }
-    /**
-     * Returns metrics for project with given key.
-     * ONLY test coverage metrics are returned as of now
-     */
-    async getMetricsByProjectKey(sonarCloudProjectKey) {
-        const token = await this.tokenProvider.getToken();
-        if (token === undefined) {
-            throw new Error("Missing token for SonarCloud");
-        }
-        const response = await fetch(`https://sonarcloud.io/api/measures/component?component=${encodeURIComponent(sonarCloudProjectKey)}&metricKeys=coverage`, {
-            method: "GET",
-            headers: {
-                Accept: "application/json",
-                Authorization: `Basic ${Buffer.from(token.concat(":"), "utf8").toString("base64")}`,
-            },
-            agent: this.config.agent,
-        });
-        if (response.status === 401) {
-            process$1.stderr.write("Unauthorized - removing token\n");
-            await this.tokenProvider.markInvalid();
-        }
-        if (response.status === 404) {
-            process$1.stderr.write(`Project ${sonarCloudProjectKey} does not exist in SonarCloud\n`);
-            return undefined;
-        }
-        if (!response.ok) {
-            throw new Error(`Response from SonarCloud not OK (${response.status}): ${await response.text()}`);
-        }
-        return (await response.json());
-    }
-}
-function createSonarCloudService(props) {
-    return new SonarCloudService({
-        config: props.config,
-        tokenProvider: props.tokenProvider ?? new SonarCloudTokenCliProvider(),
-    });
-}
-
-var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  SonarCloudService: SonarCloudService,
-  SonarCloudTokenCliProvider: SonarCloudTokenCliProvider,
-  createSonarCloudService: createSonarCloudService
-});
-
 class TestExecutor {
     shutdown = false;
     cleanupTask = null;
@@ -1394,21 +1329,21 @@ class TestExecutor {
             // This will not abort the running tasks until after
             // we have completed the cleanup tasks. The running tasks
             // can stop earlier by calling checkCanContinue.
-            process$1.on("SIGINT", () => {
+            process__default.on("SIGINT", () => {
                 console.warn("Caught interrupt signal - forcing termination");
                 if (this.cleanupTask != null) {
                     return;
                 }
                 this.shutdown = true;
                 this.cleanupTask = this.runTasks().then(() => {
-                    process$1.exit(1);
+                    process__default.exit(1);
                 });
             });
             await body(this);
         }
         catch (error) {
             console.error(error.stack || error.message || error);
-            process$1.exitCode = 1;
+            process__default.exitCode = 1;
         }
         finally {
             console.log("Reached finally block");
@@ -1601,14 +1536,14 @@ class OutputPrefixTransform extends Transform {
 function pipeToConsole(result, name) {
     result.stdout
         ?.pipe(new OutputPrefixTransform(`${name}: `))
-        .pipe(process$1.stdout);
+        .pipe(process__default.stdout);
     result.stderr
         ?.pipe(new OutputPrefixTransform(`${name} (stderr): `))
-        .pipe(process$1.stderr);
+        .pipe(process__default.stderr);
 }
 function checkPidRunning(pid) {
     try {
-        process$1.kill(pid, 0);
+        process__default.kill(pid, 0);
         return true;
     }
     catch {
@@ -1750,7 +1685,7 @@ async function runNpmRunScript(name, options) {
  * This likely does not cover all situations.
  */
 async function getDockerHostAddress() {
-    if (process$1.platform === "darwin" || process$1.platform === "win32") {
+    if (process__default.platform === "darwin" || process__default.platform === "win32") {
         return "host.docker.internal";
     }
     if (fs.existsSync("/.dockerenv")) {
@@ -1778,5 +1713,5 @@ async function waitForEnterToContinue(prompt = "Press enter to continue") {
 
 const VERSION = version;
 
-export { CacheProvider, Config, DefinitionFile, GitHubService, Reporter, TestExecutor, VERSION, createGitHubService, createNetwork, createReporter, createTestExecutor, curl, index$3 as definition, getDockerHostAddress, index$2 as github, pollForCondition, runNpmRunScript, index$1 as snyk, index as sonarCloud, startContainer, waitForEnterToContinue, waitForHttpOk, waitForPostgresAvailable };
+export { CacheProvider, Config, DefinitionFile, GitHubService, Reporter, TestExecutor, VERSION, createGitHubService, createNetwork, createReporter, createTestExecutor, curl, index$2 as definition, getDockerHostAddress, index$1 as github, pollForCondition, runNpmRunScript, index as snyk, startContainer, waitForEnterToContinue, waitForHttpOk, waitForPostgresAvailable };
 //# sourceMappingURL=index.es.js.map

package/lib/index.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/index.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import process$1 from 'node:process';
+import * as process from 'node:process';
+import process__default from 'node:process';
 import readline from 'node:readline';
 import chalk from 'chalk';
 import 'node:util';
@@ -14,14 +15,13 @@ import { performance } from 'node:perf_hooks';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
-import * as process from 'process';
 import keytar from 'keytar';
 import { strict } from 'node:assert';
 import { Transform } from 'node:stream';
 import { execa } from 'execa';
 import { read } from 'read';
 
-var version = "3.13.0";
+var version = "3.13.1";
 
 class CacheProvider {
     constructor(config) {
@@ -86,8 +86,8 @@ class Reporter {
         this.nonInteractive = !!opts.nonInteractive;
         this.isVerbose = !!opts.verbose;
     }
-    stdout = process$1.stdout;
-    stderr = process$1.stderr;
+    stdout = process__default.stdout;
+    stderr = process__default.stderr;
     nonInteractive;
     isVerbose;
     format = chalk;
@@ -110,7 +110,7 @@ class Reporter {
 }
 
 class Config {
-    cwd = path.resolve(process$1.cwd());
+    cwd = path.resolve(process__default.cwd());
     configFile = path.join(os.homedir(), ".cals-config.json");
     cacheDir = cachedir("cals-cli");
     agent = new https.Agent({
@@ -571,7 +571,7 @@ function getGitHubOrgs(definition) {
     return uniq(githubOrganizations);
 }
 
-var index$3 = /*#__PURE__*/Object.freeze({
+var index$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   DefinitionFile: DefinitionFile,
   getGitHubOrgs: getGitHubOrgs,
@@ -591,12 +591,12 @@ class GitHubTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "github-token";
     async getToken() {
-        if (process$1.env.CALS_GITHUB_TOKEN) {
-            return process$1.env.CALS_GITHUB_TOKEN;
+        if (process__default.env.CALS_GITHUB_TOKEN) {
+            return process__default.env.CALS_GITHUB_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process$1.stderr.write("No token found. Register using `cals github set-token`\n");
+            process__default.stderr.write("No token found. Register using `cals github set-token`\n");
             return undefined;
         }
         return result;
@@ -1113,7 +1113,7 @@ async function createGitHubService(props) {
     });
 }
 
-var index$2 = /*#__PURE__*/Object.freeze({
+var index$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   GitHubService: GitHubService,
   createGitHubService: createGitHubService
@@ -1123,12 +1123,12 @@ class SnykTokenCliProvider {
     keyringService = "cals";
     keyringAccount = "snyk-token";
     async getToken() {
-        if (process$1.env.CALS_SNYK_TOKEN) {
-            return process$1.env.CALS_SNYK_TOKEN;
+        if (process__default.env.CALS_SNYK_TOKEN) {
+            return process__default.env.CALS_SNYK_TOKEN;
         }
         const result = await keytar.getPassword(this.keyringService, this.keyringAccount);
         if (result == null) {
-            process$1.stderr.write("No token found. Register using `cals snyk set-token`\n");
+            process__default.stderr.write("No token found. Register using `cals snyk set-token`\n");
             return undefined;
         }
         return result;
@@ -1186,7 +1186,7 @@ class SnykService {
                 agent: this.config.agent,
             });
             if (response.status === 401) {
-                process$1.stderr.write("Unauthorized - removing token\n");
+                process__default.stderr.write("Unauthorized - removing token\n");
                 await this.tokenProvider.markInvalid();
             }
             if (!response.ok) {
@@ -1261,7 +1261,7 @@ function getGitHubRepoId(repo) {
     return repo ? `${repo.owner}/${repo.name}` : undefined;
 }
 
-var index$1 = /*#__PURE__*/Object.freeze({
+var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
   SnykService: SnykService,
   createSnykService: createSnykService,
@@ -1269,71 +1269,6 @@ var index$1 = /*#__PURE__*/Object.freeze({
   getGitHubRepoId: getGitHubRepoId
 });
 
-class SonarCloudTokenCliProvider {
-    async getToken() {
-        if (process$1.env.CALS_SONARCLOUD_TOKEN) {
-            return Promise.resolve(process$1.env.CALS_SONARCLOUD_TOKEN);
-        }
-        process$1.stderr.write("No environmental variable found. Set variable `CALS_SONARCLOUD_TOKEN` to token value\n");
-        return undefined;
-    }
-    async markInvalid() {
-        await Promise.resolve();
-    }
-}
-
-class SonarCloudService {
-    config;
-    tokenProvider;
-    constructor(props) {
-        this.config = props.config;
-        this.tokenProvider = props.tokenProvider;
-    }
-    /**
-     * Returns metrics for project with given key.
-     * ONLY test coverage metrics are returned as of now
-     */
-    async getMetricsByProjectKey(sonarCloudProjectKey) {
-        const token = await this.tokenProvider.getToken();
-        if (token === undefined) {
-            throw new Error("Missing token for SonarCloud");
-        }
-        const response = await fetch(`https://sonarcloud.io/api/measures/component?component=${encodeURIComponent(sonarCloudProjectKey)}&metricKeys=coverage`, {
-            method: "GET",
-            headers: {
-                Accept: "application/json",
-                Authorization: `Basic ${Buffer.from(token.concat(":"), "utf8").toString("base64")}`,
-            },
-            agent: this.config.agent,
-        });
-        if (response.status === 401) {
-            process$1.stderr.write("Unauthorized - removing token\n");
-            await this.tokenProvider.markInvalid();
-        }
-        if (response.status === 404) {
-            process$1.stderr.write(`Project ${sonarCloudProjectKey} does not exist in SonarCloud\n`);
-            return undefined;
-        }
-        if (!response.ok) {
-            throw new Error(`Response from SonarCloud not OK (${response.status}): ${await response.text()}`);
-        }
-        return (await response.json());
-    }
-}
-function createSonarCloudService(props) {
-    return new SonarCloudService({
-        config: props.config,
-        tokenProvider: props.tokenProvider ?? new SonarCloudTokenCliProvider(),
-    });
-}
-
-var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  SonarCloudService: SonarCloudService,
-  SonarCloudTokenCliProvider: SonarCloudTokenCliProvider,
-  createSonarCloudService: createSonarCloudService
-});
-
 class TestExecutor {
     shutdown = false;
     cleanupTask = null;
@@ -1394,21 +1329,21 @@ class TestExecutor {
             // This will not abort the running tasks until after
             // we have completed the cleanup tasks. The running tasks
             // can stop earlier by calling checkCanContinue.
-            process$1.on("SIGINT", () => {
+            process__default.on("SIGINT", () => {
                 console.warn("Caught interrupt signal - forcing termination");
                 if (this.cleanupTask != null) {
                     return;
                 }
                 this.shutdown = true;
                 this.cleanupTask = this.runTasks().then(() => {
-                    process$1.exit(1);
+                    process__default.exit(1);
                 });
             });
             await body(this);
         }
         catch (error) {
             console.error(error.stack || error.message || error);
-            process$1.exitCode = 1;
+            process__default.exitCode = 1;
         }
         finally {
             console.log("Reached finally block");
@@ -1601,14 +1536,14 @@ class OutputPrefixTransform extends Transform {
 function pipeToConsole(result, name) {
     result.stdout
         ?.pipe(new OutputPrefixTransform(`${name}: `))
-        .pipe(process$1.stdout);
+        .pipe(process__default.stdout);
     result.stderr
         ?.pipe(new OutputPrefixTransform(`${name} (stderr): `))
-        .pipe(process$1.stderr);
+        .pipe(process__default.stderr);
 }
 function checkPidRunning(pid) {
     try {
-        process$1.kill(pid, 0);
+        process__default.kill(pid, 0);
         return true;
     }
     catch {
@@ -1750,7 +1685,7 @@ async function runNpmRunScript(name, options) {
  * This likely does not cover all situations.
  */
 async function getDockerHostAddress() {
-    if (process$1.platform === "darwin" || process$1.platform === "win32") {
+    if (process__default.platform === "darwin" || process__default.platform === "win32") {
         return "host.docker.internal";
     }
     if (fs.existsSync("/.dockerenv")) {
@@ -1778,5 +1713,5 @@ async function waitForEnterToContinue(prompt = "Press enter to continue") {
 
 const VERSION = version;
 
-export { CacheProvider, Config, DefinitionFile, GitHubService, Reporter, TestExecutor, VERSION, createGitHubService, createNetwork, createReporter, createTestExecutor, curl, index$3 as definition, getDockerHostAddress, index$2 as github, pollForCondition, runNpmRunScript, index$1 as snyk, index as sonarCloud, startContainer, waitForEnterToContinue, waitForHttpOk, waitForPostgresAvailable };
+export { CacheProvider, Config, DefinitionFile, GitHubService, Reporter, TestExecutor, VERSION, createGitHubService, createNetwork, createReporter, createTestExecutor, curl, index$2 as definition, getDockerHostAddress, index$1 as github, pollForCondition, runNpmRunScript, index as snyk, startContainer, waitForEnterToContinue, waitForHttpOk, waitForPostgresAvailable };
 //# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capraconsulting/cals-cli",
-  "version": "3.13.0",
+  "version": "3.13.1",
   "description": "CLI for repeatable tasks in CALS",
   "type": "module",
   "license": "Apache-2.0",
@@ -12,6 +12,7 @@
     "lint": "biome check",
     "lint:fix": "biome check --fix",
     "format": "biome format --write",
+    "format:check": "biome format",
     "prepack": "./scripts/build-and-verify.sh",
     "semantic-release": "semantic-release",
     "watch": "rollup -c -w",
@@ -25,18 +26,16 @@
   },
   "dependencies": {
     "@octokit/rest": "^22.0.1",
-    "@types/dateformat": "5.0.3",
     "ajv": "^8.17.1",
     "cachedir": "^2.4.0",
     "chalk": "5.6.2",
-    "execa": "^9.6.0",
+    "execa": "^9.6.1",
     "find-up": "^8.0.0",
     "js-yaml": "^4.1.1",
     "keytar": "^7.9.0",
     "node-fetch": "^3.3.2",
     "p-limit": "^7.2.0",
     "p-map": "^7.0.4",
-    "process": "0.11.10",
     "read": "^5.0.1",
     "semver": "^7.7.3",
     "sprintf-js": "^1.1.3",
@@ -50,25 +49,25 @@
     "@rollup/plugin-alias": "6.0.0",
     "@rollup/plugin-json": "6.1.0",
     "@rollup/plugin-replace": "6.0.3",
+    "@types/dateformat": "5.0.3",
     "@types/js-yaml": "4.0.9",
     "@types/lodash-es": "4.17.12",
-    "@types/node": "24.10.4",
+    "@types/node": "24.10.9",
     "@types/node-fetch": "2.6.13",
     "@types/semver": "7.7.1",
     "@types/sprintf-js": "1.1.4",
     "@types/yargs": "17.0.35",
-    "@vitest/coverage-v8": "4.0.16",
-    "@vitest/ui": "4.0.16",
+    "@vitest/coverage-v8": "4.0.17",
     "dateformat": "5.0.3",
     "husky": "9.1.7",
     "npm-check-updates": "19.3.1",
-    "rollup": "4.55.1",
+    "rollup": "4.56.0",
     "rollup-plugin-typescript2": "0.36.0",
     "semantic-release": "25.0.2",
     "tsx": "4.21.0",
     "typescript": "5.9.3",
     "typescript-json-schema": "0.67.1",
-    "vitest": "4.0.16"
+    "vitest": "4.0.17"
   },
   "files": [
     "lib"

package/lib/sonarcloud/index.d.ts

@@ -1,3 +0,0 @@
-export { createSonarCloudService, SonarCloudService } from "./service";
-export type { SonarCloudTokenProvider } from "./token";
-export { SonarCloudTokenCliProvider } from "./token";

package/lib/sonarcloud/service.d.ts

@@ -1,33 +0,0 @@
-import type { Config } from "../config";
-import { type SonarCloudTokenProvider } from "./token";
-interface SonarCloudServiceProps {
-    config: Config;
-    tokenProvider: SonarCloudTokenProvider;
-}
-export declare class SonarCloudService {
-    private config;
-    private tokenProvider;
-    constructor(props: SonarCloudServiceProps);
-    /**
-     * Returns metrics for project with given key.
-     * ONLY test coverage metrics are returned as of now
-     */
-    getMetricsByProjectKey(sonarCloudProjectKey: string): Promise<{
-        component: {
-            id: string;
-            key: string;
-            name: string;
-            qualifier: string;
-            measures: {
-                metric: string;
-                value: string;
-            }[];
-        };
-    } | undefined>;
-}
-interface CreateSonarCloudServiceProps {
-    config: Config;
-    tokenProvider?: SonarCloudTokenProvider;
-}
-export declare function createSonarCloudService(props: CreateSonarCloudServiceProps): SonarCloudService;
-export {};

package/lib/sonarcloud/token.d.ts

@@ -1,8 +0,0 @@
-export interface SonarCloudTokenProvider {
-    getToken(): Promise<string | undefined>;
-    markInvalid(): Promise<void>;
-}
-export declare class SonarCloudTokenCliProvider implements SonarCloudTokenProvider {
-    getToken(): Promise<string | undefined>;
-    markInvalid(): Promise<void>;
-}