@capraconsulting/cals-cli 3.5.1 → 3.6.0

package/lib/cals-cli.js

@@ -68,7 +68,7 @@ var read__default = /*#__PURE__*/_interopDefaultLegacy(read);
 var findUp__default = /*#__PURE__*/_interopDefaultLegacy(findUp);
 var execa__default = /*#__PURE__*/_interopDefaultLegacy(execa);
 
-var version = "3.5.1";
+var version = "3.6.0";
 var engines = {
 	node: ">=12.0.0"
 };
@@ -583,7 +583,6 @@ class GitHubService {
             /* eslint-disable @typescript-eslint/no-unsafe-member-access */
             this._requestCount++;
             if (options.method !== "GET") {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return this.semaphore(() => request(options));
             }
             // Try to cache ETag for GET requests to save on rate limiting.
@@ -607,7 +606,6 @@ class GitHubService {
             }
             const getResponse = async (allowRetry = true) => {
                 try {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                     return await request(options);
                 }
                 catch (e) {
@@ -736,7 +734,6 @@ class GitHubService {
                 if (res.organization.repositories.nodes == null) {
                     throw new Error("Missing organization nodes");
                 }
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 repos.push(...res.organization.repositories.nodes);
                 if (!res.organization.repositories.pageInfo.hasNextPage) {
                     break;
@@ -1991,7 +1988,6 @@ async function createChangeSetItemsForTeams(github, definition, org) {
     });
     const overlappingTeams = actualTeams.filter((it) => wantedTeamNames.includes(it.name));
     await pMap__default["default"](overlappingTeams, async (actualTeam) => {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const wantedTeam = teams.find((it) => it.name === actualTeam.name);
         const actualMembers = await github.getTeamMemberListIncludingInvited(org, actualTeam);
         actualMembers
@@ -2256,6 +2252,7 @@ async function process$1(reporter, github, definition, getOrg, execute, limitToO
                 timeout: 60000,
             }, (err, answer) => {
                 if (err) {
+                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                     reject(err);
                 }
                 resolve(answer);
@@ -2633,6 +2630,7 @@ async function setToken$1({ reporter, token, tokenProvider, }) {
                 silent: true,
             }, (err, answer) => {
                 if (err) {
+                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                     reject(err);
                 }
                 resolve(answer);
@@ -2815,7 +2813,6 @@ async function updateReposInParallel(reporter, items) {
             };
         }
         catch (e) {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
             reporter.error(`Failed for ${repo.actualRelpath} - skipping. ${e}`);
             return null;
         }
@@ -2979,6 +2976,7 @@ async function getInput(prompt) {
             timeout: 60000,
         }, (err, answer) => {
             if (err) {
+                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                 reject(err);
             }
             resolve(answer);
@@ -3328,6 +3326,7 @@ async function setToken({ reporter, token, tokenProvider, }) {
                 silent: true,
             }, (err, answer) => {
                 if (err) {
+                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                     reject(err);
                 }
                 resolve(answer);
@@ -3411,7 +3410,7 @@ async function main() {
    / /___/ ___ |/ /______/ /
    \\____/_/  |_/_____/____/
      cli ${version}
-     built ${"2024-10-18T22:30:29+0000"}
+     built ${"2024-12-05T12:13:34+0000"}
 
 https://github.com/capralifecycle/cals-cli/
 

package/lib/cals-cli.js.map

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

package/lib/index.d.ts

@@ -7,7 +7,6 @@ import { createGitHubService, GitHubService } from "./github/service";
 export declare const VERSION: string;
 export * as definition from "./definition";
 export * as github from "./github";
-export * as loadSecrets from "./load-secrets";
 export * as snyk from "./snyk";
 export * as sonarCloud from "./sonarcloud";
 export * from "./testing";

package/lib/index.es.js

@@ -16,14 +16,12 @@ import pLimit from 'p-limit';
 import keytar from 'keytar';
 import * as process$1 from 'process';
 import { performance } from 'perf_hooks';
-import { SecretsManagerClient, DescribeSecretCommand, UntagResourceCommand, TagResourceCommand, GetSecretValueCommand, CreateSecretCommand, RestoreSecretCommand, PutSecretValueCommand, ReplicateSecretToRegionsCommand, RemoveRegionsFromReplicationCommand } from '@aws-sdk/client-secrets-manager';
-import { STSClient, GetCallerIdentityCommand } from '@aws-sdk/client-sts';
-import read from 'read';
 import { strict } from 'assert';
 import execa from 'execa';
+import read from 'read';
 import { Transform } from 'stream';
 
-var version = "3.5.1";
+var version = "3.6.0";
 
 class CacheProvider {
     constructor(config) {
@@ -639,7 +637,6 @@ class GitHubService {
             /* eslint-disable @typescript-eslint/no-unsafe-member-access */
             this._requestCount++;
             if (options.method !== "GET") {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return this.semaphore(() => request(options));
             }
             // Try to cache ETag for GET requests to save on rate limiting.
@@ -663,7 +660,6 @@ class GitHubService {
             }
             const getResponse = async (allowRetry = true) => {
                 try {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                     return await request(options);
                 }
                 catch (e) {
@@ -792,7 +788,6 @@ class GitHubService {
                 if (res.organization.repositories.nodes == null) {
                     throw new Error("Missing organization nodes");
                 }
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 repos.push(...res.organization.repositories.nodes);
                 if (!res.organization.repositories.pageInfo.hasNextPage) {
                     break;
@@ -1132,7 +1127,7 @@ async function createGitHubService(props) {
     });
 }
 
-var index$4 = /*#__PURE__*/Object.freeze({
+var index$3 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   DefinitionFile: DefinitionFile,
   getGitHubOrgs: getGitHubOrgs,
@@ -1141,336 +1136,12 @@ var index$4 = /*#__PURE__*/Object.freeze({
   parseDefinition: parseDefinition
 });
 
-var index$3 = /*#__PURE__*/Object.freeze({
+var index$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createGitHubService: createGitHubService,
   GitHubService: GitHubService
 });
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-class LoadSecrets {
-    constructor(props) {
-        this.smClientForRegions = {};
-        this.stsClient = new STSClient({
-            region: "eu-west-1",
-        });
-        this.reporter = props.reporter;
-        this.silent = props.silent;
-    }
-    getSmClient(region) {
-        if (!this.smClientForRegions[region]) {
-            this.smClientForRegions[region] = new SecretsManagerClient({
-                region,
-            });
-        }
-        return this.smClientForRegions[region];
-    }
-    async getInput(options) {
-        return new Promise((resolve, reject) => {
-            read(options, (err, answer) => {
-                if (err) {
-                    reject(err);
-                }
-                resolve(answer);
-            });
-        });
-    }
-    async getSecretDetails(client, secretId) {
-        try {
-            return await client.send(new DescribeSecretCommand({ SecretId: secretId }));
-        }
-        catch (e) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            if (e.name && e.name === "ResourceNotFoundException") {
-                return null;
-            }
-            throw e;
-        }
-    }
-    async handleStringUpdate() {
-        return await this.getInput({
-            prompt: "Enter value (Ctrl+C to abort): ",
-            silent: this.silent,
-        });
-    }
-    async handleJsonUpdate(secret) {
-        this.reporter.log("The secret is of type JSON with these expected fields:");
-        for (const field of secret.fields) {
-            const key = typeof field === "string" ? field : field.key;
-            const desc = typeof field === "string"
-                ? ""
-                : field.description
-                    ? ` (${field.description})`
-                    : "";
-            this.reporter.log(`  - ${key}${desc}`);
-        }
-        this.reporter.log("");
-        // TODO: Ability to specify full json value as one line.
-        const collectedValues = {};
-        for (const field of secret.fields) {
-            const key = typeof field === "string" ? field : field.key;
-            this.reporter.log(`Field: ${this.reporter.format.greenBright(key)}`);
-            if (typeof field !== "string" && field.example != null) {
-                this.reporter.log(`Example: ${this.reporter.format.magentaBright(field.example)}`);
-            }
-            const value = await this.getInput({
-                prompt: "Enter value (Ctrl+C to abort): ",
-                silent: this.silent,
-            });
-            collectedValues[key] = value;
-            this.reporter.log("");
-        }
-        return JSON.stringify(collectedValues, undefined, "  ");
-    }
-    getFullName(secretGroup, secret) {
-        return `${secretGroup.namePrefix}${secret.name}`;
-    }
-    async syncTags(client, secret, tags) {
-        const keysToRemove = secret
-            .Tags.filter((existingTag) => !tags.some((it) => it.Key === existingTag.Key))
-            .map((it) => it.Key);
-        if (keysToRemove.length > 0) {
-            this.reporter.log(`Removing obsolete tags: ${keysToRemove.join(", ")}`);
-            await client.send(new UntagResourceCommand({
-                SecretId: secret.ARN,
-                TagKeys: keysToRemove,
-            }));
-        }
-        const tagsToUpdate = tags.filter((expectedTag) => {
-            const existing = secret.Tags.find((it) => it.Key === expectedTag.Key);
-            return existing == null || existing.Value != expectedTag.Value;
-        });
-        if (tagsToUpdate.length > 0) {
-            this.reporter.log(`Storing tags: ${tagsToUpdate.map((it) => it.Key).join(", ")}`);
-            await client.send(new TagResourceCommand({
-                SecretId: secret.ARN,
-                Tags: tagsToUpdate,
-            }));
-        }
-    }
-    async getSecretValue(client, secretId) {
-        const result = await client.send(new GetSecretValueCommand({
-            SecretId: secretId,
-        }));
-        if (result.SecretString == null) {
-            throw new Error("Missing SecretString (is it a binary?)");
-        }
-        return result.SecretString;
-    }
-    async handleUpdate(secretGroup, secret) {
-        var _a, _b, _c, _d, _e;
-        const client = this.getSmClient(secretGroup.region);
-        const fullName = this.getFullName(secretGroup, secret);
-        const describeSecret = await this.getSecretDetails(client, fullName);
-        this.reporter.log(`Secret: ${this.reporter.format.greenBright(fullName)}`);
-        if (describeSecret == null) {
-            this.reporter.log("The secret does not already exist and will be created");
-        }
-        else {
-            this.reporter.log("Current value:");
-            this.reporter.log(this.reporter.format.yellowBright((await this.getSecretValue(client, fullName)).replace(/^/gm, "  ")));
-        }
-        this.reporter.log("");
-        let secretValue;
-        if (secret.type === "json") {
-            try {
-                secretValue = await this.handleJsonUpdate(secret);
-            }
-            catch (e) {
-                if (e instanceof Error && e.message === "canceled") {
-                    this.reporter.log("Aborted");
-                    return;
-                }
-                throw e;
-            }
-        }
-        else if (secret.type === "string") {
-            secretValue = await this.handleStringUpdate();
-        }
-        else {
-            throw new Error(`Unsupported type`);
-        }
-        this.reporter.log("Storing secret value:");
-        this.reporter.log(this.reporter.format.yellowBright(secretValue.replace(/^/gm, "  ")));
-        const tags = [
-            {
-                Key: "Source",
-                Value: "load-secrets script",
-            },
-        ];
-        let arn;
-        let version;
-        let newReplicaRegions = [];
-        let removedReplicaRegions = [];
-        if (describeSecret == null) {
-            newReplicaRegions = (_a = secret.replicaRegions) !== null && _a !== void 0 ? _a : [];
-            const createResult = await client.send(new CreateSecretCommand({
-                Name: fullName,
-                AddReplicaRegions: secret.replicaRegions
-                    ? secret.replicaRegions.map((replicaRegion) => ({
-                        Region: replicaRegion,
-                    }))
-                    : undefined,
-                Description: "Created by load-secrets",
-                SecretString: secretValue,
-                Tags: tags,
-            }));
-            if (createResult.VersionId == null) {
-                throw new Error("Expected versionId");
-            }
-            arn = createResult.ARN;
-            version = createResult.VersionId;
-        }
-        else {
-            if (describeSecret.DeletedDate != null) {
-                await client.send(new RestoreSecretCommand({
-                    SecretId: fullName,
-                }));
-            }
-            const updateResult = await client.send(new PutSecretValueCommand({
-                SecretId: fullName,
-                SecretString: secretValue,
-            }));
-            const currentReplicaRegions = (_c = (_b = describeSecret.ReplicationStatus) === null || _b === void 0 ? void 0 : _b.map((replicationStatus) => replicationStatus.Region)) !== null && _c !== void 0 ? _c : [];
-            newReplicaRegions =
-                (_e = (_d = secret.replicaRegions) === null || _d === void 0 ? void 0 : _d.filter((region) => !currentReplicaRegions.includes(region))) !== null && _e !== void 0 ? _e : [];
-            removedReplicaRegions = currentReplicaRegions
-                .filter((region) => !!region && typeof region === "string")
-                .filter((region) => !(secret.replicaRegions || []).includes(region));
-            if (newReplicaRegions.length > 0) {
-                await client.send(new ReplicateSecretToRegionsCommand({
-                    SecretId: fullName,
-                    AddReplicaRegions: newReplicaRegions.map((region) => ({
-                        Region: region,
-                    })),
-                }));
-            }
-            if (removedReplicaRegions.length > 0) {
-                await client.send(new RemoveRegionsFromReplicationCommand({
-                    SecretId: fullName,
-                    RemoveReplicaRegions: removedReplicaRegions,
-                }));
-            }
-            if (updateResult.VersionId == null) {
-                throw new Error("Expected versionId");
-            }
-            await this.syncTags(client, describeSecret, tags);
-            arn = updateResult.ARN;
-            version = updateResult.VersionId;
-        }
-        this.reporter.log("");
-        this.reporter.log("Secret stored:");
-        this.reporter.log(`ARN: ${this.reporter.format.greenBright(arn)}`);
-        this.reporter.log(`Version: ${this.reporter.format.greenBright(version)}`);
-        if (newReplicaRegions.length > 0) {
-            this.reporter.log(`Read replicas added to regions: ${newReplicaRegions
-                .map((r) => this.reporter.format.greenBright(r))
-                .join(", ")}`);
-        }
-        if (removedReplicaRegions.length > 0) {
-            this.reporter.log(`Read replicas removed from regions: ${removedReplicaRegions
-                .map((r) => this.reporter.format.redBright(r))
-                .join(", ")}`);
-        }
-    }
-    checkSecretGroup(secretGroup) {
-        if (!secretGroup.namePrefix.startsWith("/") ||
-            !secretGroup.namePrefix.endsWith("/")) {
-            throw new Error(`namePrefix should start and end with /. Current value: ${secretGroup.namePrefix}`);
-        }
-    }
-    getSecretDescription(details) {
-        var _a, _b;
-        return details == null
-            ? "not yet created"
-            : (details === null || details === void 0 ? void 0 : details.DeletedDate) != null
-                ? `scheduled for deletion ${details.DeletedDate.toISOString()}`
-                : `last changed ${(_b = (_a = details.LastChangedDate) === null || _a === void 0 ? void 0 : _a.toISOString()) !== null && _b !== void 0 ? _b : "unknown"}`;
-    }
-    /**
-     * Returns false if aborted.
-     */
-    async selectAndUpdate(secretGroups) {
-        const secrets = [];
-        this.reporter.log("Select secret to write:");
-        this.reporter.log("");
-        for (const secretGroup of secretGroups) {
-            this.reporter.log(`${secretGroup.description} (prefix: ${secretGroup.namePrefix})`);
-            for (let i = 0; i < secretGroup.secrets.length; i++) {
-                const offset = secrets.length;
-                const secret = secretGroup.secrets[i];
-                secrets.push({
-                    secret: secret,
-                    secretGroup,
-                });
-                const client = this.getSmClient(secretGroup.region);
-                const details = await this.getSecretDetails(client, this.getFullName(secretGroup, secret));
-                const desc = this.getSecretDescription(details);
-                this.reporter.log(`  (${offset}) ${secret.name} (${desc})`);
-            }
-            this.reporter.log("");
-        }
-        let index;
-        try {
-            const answer = await this.getInput({
-                prompt: "Enter index (or enter to quit): ",
-            });
-            if (answer.trim() === "") {
-                return false;
-            }
-            index = parseInt(answer);
-            if (!secrets[index]) {
-                throw new Error();
-            }
-        }
-        catch (e) {
-            this.reporter.warn("Secret not found - aborting");
-            return false;
-        }
-        this.reporter.log("");
-        await this.handleUpdate(secrets[index].secretGroup, secrets[index].secret);
-        this.reporter.log("");
-        return true;
-    }
-    async process(secretGroups) {
-        this.reporter.info("Checking account for current credentials");
-        this.reporter.info("If any error is given, make sure you have valid credentials active");
-        const currentAccount = await this.stsClient.send(new GetCallerIdentityCommand({}));
-        this.reporter.info(`Running for account ${currentAccount.Account}`);
-        this.reporter.log("");
-        const matchedSecretGroups = secretGroups.filter((it) => it.accountId === currentAccount.Account);
-        if (matchedSecretGroups.length === 0) {
-            this.reporter.error(`No secrets specified for this account - aborting`);
-            return;
-        }
-        for (const secretGroup of matchedSecretGroups) {
-            this.checkSecretGroup(secretGroup);
-        }
-        while (await this.selectAndUpdate(matchedSecretGroups)) { }
-    }
-}
-/**
- * Load secrets interactively into Secrets Manager.
- */
-function loadSecretsCli(props) {
-    const loadSecrets = new LoadSecrets({
-        reporter: createReporter({}),
-        // For now we show the secrets, so that we get positive feedback that the value
-        // is correctly entered.
-        silent: false,
-    });
-    loadSecrets.process(props.secretGroups).catch((error) => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        console.error(error.stack || error.message || error);
-        process.exitCode = 1;
-    });
-}
-
-var index$2 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  loadSecretsCli: loadSecretsCli
-});
-
 class SnykTokenCliProvider {
     constructor() {
         this.keyringService = "cals";
@@ -1878,7 +1549,7 @@ async function pollForCondition({ container, attempts, waitIntervalSec, conditio
             log(`Took ${duration()} seconds for condition`);
             return;
         }
-        catch (e) {
+        catch {
             log("Still waiting...");
             await new Promise((resolve) => setTimeout(resolve, waitIntervalSec * 1000));
         }
@@ -1926,7 +1597,7 @@ async function isRunning(executor, container) {
         await execa("docker", ["inspect", container.name]);
         return true;
     }
-    catch (e) {
+    catch {
         return false;
     }
 }
@@ -1967,7 +1638,7 @@ function checkPidRunning(pid) {
         process.kill(pid, 0);
         return true;
     }
-    catch (e) {
+    catch {
         return false;
     }
 }
@@ -1981,7 +1652,7 @@ async function getContainerId({ executor, name, hasFailed, pid, }) {
             result = (await execa("docker", ["inspect", name, "-f", "{{.Id}}"]))
                 .stdout;
         }
-        catch (e) {
+        catch {
             result = null;
         }
         // Debugging to help us solve CALS-366.
@@ -2115,13 +1786,12 @@ async function getDockerHostAddress() {
         pipeToConsole(process, "ip route");
         const res = await process;
         try {
-            return (res.stdout
+            return res.stdout
                 .split("\n")
                 .filter((it) => it.includes("default via"))
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                .map((it) => /default via ([\d\.]+) /.exec(it)[1])[0]);
+                .map((it) => /default via ([\d\.]+) /.exec(it)[1])[0];
         }
-        catch (e) {
+        catch {
             throw new Error("Failed to extract docker host address");
         }
     }
@@ -2134,6 +1804,7 @@ async function waitForEnterToContinue(prompt = "Press enter to continue") {
             silent: true,
         }, (err) => {
             if (err) {
+                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                 reject(err);
             }
             resolve();
@@ -2143,5 +1814,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$4 as definition, getDockerHostAddress, index$3 as github, index$2 as loadSecrets, 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$3 as definition, getDockerHostAddress, index$2 as github, pollForCondition, runNpmRunScript, index$1 as snyk, index as sonarCloud, 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

@@ -20,11 +20,9 @@ var pLimit = require('p-limit');
 var keytar = require('keytar');
 var process$1 = require('process');
 var perf_hooks = require('perf_hooks');
-var clientSecretsManager = require('@aws-sdk/client-secrets-manager');
-var clientSts = require('@aws-sdk/client-sts');
-var read = require('read');
 var assert = require('assert');
 var execa = require('execa');
+var read = require('read');
 var stream = require('stream');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -61,10 +59,10 @@ var fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
 var pLimit__default = /*#__PURE__*/_interopDefaultLegacy(pLimit);
 var keytar__default = /*#__PURE__*/_interopDefaultLegacy(keytar);
 var process__namespace = /*#__PURE__*/_interopNamespace(process$1);
-var read__default = /*#__PURE__*/_interopDefaultLegacy(read);
 var execa__default = /*#__PURE__*/_interopDefaultLegacy(execa);
+var read__default = /*#__PURE__*/_interopDefaultLegacy(read);
 
-var version = "3.5.1";
+var version = "3.6.0";
 
 class CacheProvider {
     constructor(config) {
@@ -680,7 +678,6 @@ class GitHubService {
             /* eslint-disable @typescript-eslint/no-unsafe-member-access */
             this._requestCount++;
             if (options.method !== "GET") {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                 return this.semaphore(() => request(options));
             }
             // Try to cache ETag for GET requests to save on rate limiting.
@@ -704,7 +701,6 @@ class GitHubService {
             }
             const getResponse = async (allowRetry = true) => {
                 try {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
                     return await request(options);
                 }
                 catch (e) {
@@ -833,7 +829,6 @@ class GitHubService {
                 if (res.organization.repositories.nodes == null) {
                     throw new Error("Missing organization nodes");
                 }
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 repos.push(...res.organization.repositories.nodes);
                 if (!res.organization.repositories.pageInfo.hasNextPage) {
                     break;
@@ -1173,7 +1168,7 @@ async function createGitHubService(props) {
     });
 }
 
-var index$4 = /*#__PURE__*/Object.freeze({
+var index$3 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   DefinitionFile: DefinitionFile,
   getGitHubOrgs: getGitHubOrgs,
@@ -1182,336 +1177,12 @@ var index$4 = /*#__PURE__*/Object.freeze({
   parseDefinition: parseDefinition
 });
 
-var index$3 = /*#__PURE__*/Object.freeze({
+var index$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createGitHubService: createGitHubService,
   GitHubService: GitHubService
 });
 
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-class LoadSecrets {
-    constructor(props) {
-        this.smClientForRegions = {};
-        this.stsClient = new clientSts.STSClient({
-            region: "eu-west-1",
-        });
-        this.reporter = props.reporter;
-        this.silent = props.silent;
-    }
-    getSmClient(region) {
-        if (!this.smClientForRegions[region]) {
-            this.smClientForRegions[region] = new clientSecretsManager.SecretsManagerClient({
-                region,
-            });
-        }
-        return this.smClientForRegions[region];
-    }
-    async getInput(options) {
-        return new Promise((resolve, reject) => {
-            read__default["default"](options, (err, answer) => {
-                if (err) {
-                    reject(err);
-                }
-                resolve(answer);
-            });
-        });
-    }
-    async getSecretDetails(client, secretId) {
-        try {
-            return await client.send(new clientSecretsManager.DescribeSecretCommand({ SecretId: secretId }));
-        }
-        catch (e) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            if (e.name && e.name === "ResourceNotFoundException") {
-                return null;
-            }
-            throw e;
-        }
-    }
-    async handleStringUpdate() {
-        return await this.getInput({
-            prompt: "Enter value (Ctrl+C to abort): ",
-            silent: this.silent,
-        });
-    }
-    async handleJsonUpdate(secret) {
-        this.reporter.log("The secret is of type JSON with these expected fields:");
-        for (const field of secret.fields) {
-            const key = typeof field === "string" ? field : field.key;
-            const desc = typeof field === "string"
-                ? ""
-                : field.description
-                    ? ` (${field.description})`
-                    : "";
-            this.reporter.log(`  - ${key}${desc}`);
-        }
-        this.reporter.log("");
-        // TODO: Ability to specify full json value as one line.
-        const collectedValues = {};
-        for (const field of secret.fields) {
-            const key = typeof field === "string" ? field : field.key;
-            this.reporter.log(`Field: ${this.reporter.format.greenBright(key)}`);
-            if (typeof field !== "string" && field.example != null) {
-                this.reporter.log(`Example: ${this.reporter.format.magentaBright(field.example)}`);
-            }
-            const value = await this.getInput({
-                prompt: "Enter value (Ctrl+C to abort): ",
-                silent: this.silent,
-            });
-            collectedValues[key] = value;
-            this.reporter.log("");
-        }
-        return JSON.stringify(collectedValues, undefined, "  ");
-    }
-    getFullName(secretGroup, secret) {
-        return `${secretGroup.namePrefix}${secret.name}`;
-    }
-    async syncTags(client, secret, tags) {
-        const keysToRemove = secret
-            .Tags.filter((existingTag) => !tags.some((it) => it.Key === existingTag.Key))
-            .map((it) => it.Key);
-        if (keysToRemove.length > 0) {
-            this.reporter.log(`Removing obsolete tags: ${keysToRemove.join(", ")}`);
-            await client.send(new clientSecretsManager.UntagResourceCommand({
-                SecretId: secret.ARN,
-                TagKeys: keysToRemove,
-            }));
-        }
-        const tagsToUpdate = tags.filter((expectedTag) => {
-            const existing = secret.Tags.find((it) => it.Key === expectedTag.Key);
-            return existing == null || existing.Value != expectedTag.Value;
-        });
-        if (tagsToUpdate.length > 0) {
-            this.reporter.log(`Storing tags: ${tagsToUpdate.map((it) => it.Key).join(", ")}`);
-            await client.send(new clientSecretsManager.TagResourceCommand({
-                SecretId: secret.ARN,
-                Tags: tagsToUpdate,
-            }));
-        }
-    }
-    async getSecretValue(client, secretId) {
-        const result = await client.send(new clientSecretsManager.GetSecretValueCommand({
-            SecretId: secretId,
-        }));
-        if (result.SecretString == null) {
-            throw new Error("Missing SecretString (is it a binary?)");
-        }
-        return result.SecretString;
-    }
-    async handleUpdate(secretGroup, secret) {
-        var _a, _b, _c, _d, _e;
-        const client = this.getSmClient(secretGroup.region);
-        const fullName = this.getFullName(secretGroup, secret);
-        const describeSecret = await this.getSecretDetails(client, fullName);
-        this.reporter.log(`Secret: ${this.reporter.format.greenBright(fullName)}`);
-        if (describeSecret == null) {
-            this.reporter.log("The secret does not already exist and will be created");
-        }
-        else {
-            this.reporter.log("Current value:");
-            this.reporter.log(this.reporter.format.yellowBright((await this.getSecretValue(client, fullName)).replace(/^/gm, "  ")));
-        }
-        this.reporter.log("");
-        let secretValue;
-        if (secret.type === "json") {
-            try {
-                secretValue = await this.handleJsonUpdate(secret);
-            }
-            catch (e) {
-                if (e instanceof Error && e.message === "canceled") {
-                    this.reporter.log("Aborted");
-                    return;
-                }
-                throw e;
-            }
-        }
-        else if (secret.type === "string") {
-            secretValue = await this.handleStringUpdate();
-        }
-        else {
-            throw new Error(`Unsupported type`);
-        }
-        this.reporter.log("Storing secret value:");
-        this.reporter.log(this.reporter.format.yellowBright(secretValue.replace(/^/gm, "  ")));
-        const tags = [
-            {
-                Key: "Source",
-                Value: "load-secrets script",
-            },
-        ];
-        let arn;
-        let version;
-        let newReplicaRegions = [];
-        let removedReplicaRegions = [];
-        if (describeSecret == null) {
-            newReplicaRegions = (_a = secret.replicaRegions) !== null && _a !== void 0 ? _a : [];
-            const createResult = await client.send(new clientSecretsManager.CreateSecretCommand({
-                Name: fullName,
-                AddReplicaRegions: secret.replicaRegions
-                    ? secret.replicaRegions.map((replicaRegion) => ({
-                        Region: replicaRegion,
-                    }))
-                    : undefined,
-                Description: "Created by load-secrets",
-                SecretString: secretValue,
-                Tags: tags,
-            }));
-            if (createResult.VersionId == null) {
-                throw new Error("Expected versionId");
-            }
-            arn = createResult.ARN;
-            version = createResult.VersionId;
-        }
-        else {
-            if (describeSecret.DeletedDate != null) {
-                await client.send(new clientSecretsManager.RestoreSecretCommand({
-                    SecretId: fullName,
-                }));
-            }
-            const updateResult = await client.send(new clientSecretsManager.PutSecretValueCommand({
-                SecretId: fullName,
-                SecretString: secretValue,
-            }));
-            const currentReplicaRegions = (_c = (_b = describeSecret.ReplicationStatus) === null || _b === void 0 ? void 0 : _b.map((replicationStatus) => replicationStatus.Region)) !== null && _c !== void 0 ? _c : [];
-            newReplicaRegions =
-                (_e = (_d = secret.replicaRegions) === null || _d === void 0 ? void 0 : _d.filter((region) => !currentReplicaRegions.includes(region))) !== null && _e !== void 0 ? _e : [];
-            removedReplicaRegions = currentReplicaRegions
-                .filter((region) => !!region && typeof region === "string")
-                .filter((region) => !(secret.replicaRegions || []).includes(region));
-            if (newReplicaRegions.length > 0) {
-                await client.send(new clientSecretsManager.ReplicateSecretToRegionsCommand({
-                    SecretId: fullName,
-                    AddReplicaRegions: newReplicaRegions.map((region) => ({
-                        Region: region,
-                    })),
-                }));
-            }
-            if (removedReplicaRegions.length > 0) {
-                await client.send(new clientSecretsManager.RemoveRegionsFromReplicationCommand({
-                    SecretId: fullName,
-                    RemoveReplicaRegions: removedReplicaRegions,
-                }));
-            }
-            if (updateResult.VersionId == null) {
-                throw new Error("Expected versionId");
-            }
-            await this.syncTags(client, describeSecret, tags);
-            arn = updateResult.ARN;
-            version = updateResult.VersionId;
-        }
-        this.reporter.log("");
-        this.reporter.log("Secret stored:");
-        this.reporter.log(`ARN: ${this.reporter.format.greenBright(arn)}`);
-        this.reporter.log(`Version: ${this.reporter.format.greenBright(version)}`);
-        if (newReplicaRegions.length > 0) {
-            this.reporter.log(`Read replicas added to regions: ${newReplicaRegions
-                .map((r) => this.reporter.format.greenBright(r))
-                .join(", ")}`);
-        }
-        if (removedReplicaRegions.length > 0) {
-            this.reporter.log(`Read replicas removed from regions: ${removedReplicaRegions
-                .map((r) => this.reporter.format.redBright(r))
-                .join(", ")}`);
-        }
-    }
-    checkSecretGroup(secretGroup) {
-        if (!secretGroup.namePrefix.startsWith("/") ||
-            !secretGroup.namePrefix.endsWith("/")) {
-            throw new Error(`namePrefix should start and end with /. Current value: ${secretGroup.namePrefix}`);
-        }
-    }
-    getSecretDescription(details) {
-        var _a, _b;
-        return details == null
-            ? "not yet created"
-            : (details === null || details === void 0 ? void 0 : details.DeletedDate) != null
-                ? `scheduled for deletion ${details.DeletedDate.toISOString()}`
-                : `last changed ${(_b = (_a = details.LastChangedDate) === null || _a === void 0 ? void 0 : _a.toISOString()) !== null && _b !== void 0 ? _b : "unknown"}`;
-    }
-    /**
-     * Returns false if aborted.
-     */
-    async selectAndUpdate(secretGroups) {
-        const secrets = [];
-        this.reporter.log("Select secret to write:");
-        this.reporter.log("");
-        for (const secretGroup of secretGroups) {
-            this.reporter.log(`${secretGroup.description} (prefix: ${secretGroup.namePrefix})`);
-            for (let i = 0; i < secretGroup.secrets.length; i++) {
-                const offset = secrets.length;
-                const secret = secretGroup.secrets[i];
-                secrets.push({
-                    secret: secret,
-                    secretGroup,
-                });
-                const client = this.getSmClient(secretGroup.region);
-                const details = await this.getSecretDetails(client, this.getFullName(secretGroup, secret));
-                const desc = this.getSecretDescription(details);
-                this.reporter.log(`  (${offset}) ${secret.name} (${desc})`);
-            }
-            this.reporter.log("");
-        }
-        let index;
-        try {
-            const answer = await this.getInput({
-                prompt: "Enter index (or enter to quit): ",
-            });
-            if (answer.trim() === "") {
-                return false;
-            }
-            index = parseInt(answer);
-            if (!secrets[index]) {
-                throw new Error();
-            }
-        }
-        catch (e) {
-            this.reporter.warn("Secret not found - aborting");
-            return false;
-        }
-        this.reporter.log("");
-        await this.handleUpdate(secrets[index].secretGroup, secrets[index].secret);
-        this.reporter.log("");
-        return true;
-    }
-    async process(secretGroups) {
-        this.reporter.info("Checking account for current credentials");
-        this.reporter.info("If any error is given, make sure you have valid credentials active");
-        const currentAccount = await this.stsClient.send(new clientSts.GetCallerIdentityCommand({}));
-        this.reporter.info(`Running for account ${currentAccount.Account}`);
-        this.reporter.log("");
-        const matchedSecretGroups = secretGroups.filter((it) => it.accountId === currentAccount.Account);
-        if (matchedSecretGroups.length === 0) {
-            this.reporter.error(`No secrets specified for this account - aborting`);
-            return;
-        }
-        for (const secretGroup of matchedSecretGroups) {
-            this.checkSecretGroup(secretGroup);
-        }
-        while (await this.selectAndUpdate(matchedSecretGroups)) { }
-    }
-}
-/**
- * Load secrets interactively into Secrets Manager.
- */
-function loadSecretsCli(props) {
-    const loadSecrets = new LoadSecrets({
-        reporter: createReporter({}),
-        // For now we show the secrets, so that we get positive feedback that the value
-        // is correctly entered.
-        silent: false,
-    });
-    loadSecrets.process(props.secretGroups).catch((error) => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        console.error(error.stack || error.message || error);
-        process.exitCode = 1;
-    });
-}
-
-var index$2 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  loadSecretsCli: loadSecretsCli
-});
-
 class SnykTokenCliProvider {
     constructor() {
         this.keyringService = "cals";
@@ -1919,7 +1590,7 @@ async function pollForCondition({ container, attempts, waitIntervalSec, conditio
             log(`Took ${duration()} seconds for condition`);
             return;
         }
-        catch (e) {
+        catch {
             log("Still waiting...");
             await new Promise((resolve) => setTimeout(resolve, waitIntervalSec * 1000));
         }
@@ -1967,7 +1638,7 @@ async function isRunning(executor, container) {
         await execa__default["default"]("docker", ["inspect", container.name]);
         return true;
     }
-    catch (e) {
+    catch {
         return false;
     }
 }
@@ -2008,7 +1679,7 @@ function checkPidRunning(pid) {
         process.kill(pid, 0);
         return true;
     }
-    catch (e) {
+    catch {
         return false;
     }
 }
@@ -2022,7 +1693,7 @@ async function getContainerId({ executor, name, hasFailed, pid, }) {
             result = (await execa__default["default"]("docker", ["inspect", name, "-f", "{{.Id}}"]))
                 .stdout;
         }
-        catch (e) {
+        catch {
             result = null;
         }
         // Debugging to help us solve CALS-366.
@@ -2156,13 +1827,12 @@ async function getDockerHostAddress() {
         pipeToConsole(process, "ip route");
         const res = await process;
         try {
-            return (res.stdout
+            return res.stdout
                 .split("\n")
                 .filter((it) => it.includes("default via"))
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                .map((it) => /default via ([\d\.]+) /.exec(it)[1])[0]);
+                .map((it) => /default via ([\d\.]+) /.exec(it)[1])[0];
         }
-        catch (e) {
+        catch {
             throw new Error("Failed to extract docker host address");
         }
     }
@@ -2175,6 +1845,7 @@ async function waitForEnterToContinue(prompt = "Press enter to continue") {
             silent: true,
         }, (err) => {
             if (err) {
+                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                 reject(err);
             }
             resolve();
@@ -2196,10 +1867,9 @@ exports.createNetwork = createNetwork;
 exports.createReporter = createReporter;
 exports.createTestExecutor = createTestExecutor;
 exports.curl = curl;
-exports.definition = index$4;
+exports.definition = index$3;
 exports.getDockerHostAddress = getDockerHostAddress;
-exports.github = index$3;
-exports.loadSecrets = index$2;
+exports.github = index$2;
 exports.pollForCondition = pollForCondition;
 exports.runNpmRunScript = runNpmRunScript;
 exports.snyk = index$1;

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.5.1",
+  "version": "3.6.0",
   "description": "CLI for repeatable tasks in CALS",
   "scripts": {
     "prepare": "node scripts/create-definition-schema.js && husky install",
@@ -21,8 +21,6 @@
     "cals": "lib/cals-cli.js"
   },
   "dependencies": {
-    "@aws-sdk/client-secrets-manager": "^3.621.0",
-    "@aws-sdk/client-sts": "^3.577.0",
     "@octokit/rest": "^19.0.0",
     "ajv": "^8.11.0",
     "cachedir": "^2.4.0",
@@ -47,38 +45,40 @@
     }
   },
   "devDependencies": {
-    "@commitlint/cli": "19.5.0",
-    "@commitlint/config-conventional": "19.5.0",
+    "@commitlint/cli": "19.6.0",
+    "@commitlint/config-conventional": "19.6.0",
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.16.0",
     "@octokit/types": "10.0.0",
     "@rollup/plugin-alias": "5.1.1",
     "@rollup/plugin-json": "6.1.0",
-    "@rollup/plugin-replace": "5.0.7",
-    "@types/jest": "29.5.13",
+    "@rollup/plugin-replace": "6.0.1",
+    "@types/jest": "29.5.14",
     "@types/js-yaml": "4.0.9",
-    "@types/lodash": "4.17.10",
-    "@types/node": "20.16.11",
-    "@types/node-fetch": "2.6.11",
+    "@types/lodash": "4.17.13",
+    "@types/node": "22.10.1",
+    "@types/node-fetch": "2.6.12",
     "@types/read": "0.0.32",
     "@types/rimraf": "3.0.2",
     "@types/semver": "7.5.8",
     "@types/sprintf-js": "1.1.4",
     "@types/yargs": "17.0.33",
-    "@typescript-eslint/eslint-plugin": "7.18.0",
-    "@typescript-eslint/parser": "7.18.0",
+    "@typescript-eslint/eslint-plugin": "8.17.0",
+    "@typescript-eslint/parser": "8.17.0",
     "dateformat": "4.6.3",
     "del": "6.1.1",
-    "eslint": "8.57.1",
+    "eslint": "9.16.0",
     "eslint-config-prettier": "9.1.0",
     "eslint-plugin-prettier": "5.2.1",
     "husky": "8.0.3",
     "jest": "^29.6.1",
-    "prettier": "3.3.3",
+    "prettier": "3.4.1",
     "rollup": "2.79.2",
     "rollup-plugin-typescript2": "0.36.0",
-    "semantic-release": "24.1.2",
+    "semantic-release": "24.2.0",
     "tempy": "1.0.1",
     "ts-jest": "^29.1.1",
-    "typescript": "5.6.3",
+    "typescript": "5.7.2",
     "typescript-json-schema": "0.65.1"
   },
   "files": [

package/lib/load-secrets/index.d.ts

@@ -1,2 +0,0 @@
-export { loadSecretsCli } from "./load-secrets";
-export { JsonSecret, Secret, SecretGroup } from "./types";

package/lib/load-secrets/load-secrets.d.ts

@@ -1,7 +0,0 @@
-import { SecretGroup } from "./types";
-/**
- * Load secrets interactively into Secrets Manager.
- */
-export declare function loadSecretsCli(props: {
-    secretGroups: SecretGroup[];
-}): void;

package/lib/load-secrets/types.d.ts

@@ -1,34 +0,0 @@
-export interface BaseSecret {
-    name: string;
-    description?: string;
-    /**
-     * A list of regions to create read replicas
-     * of the secret in.
-     */
-    replicaRegions?: string[];
-}
-export type JsonSecretSimpleField = string;
-export interface JsonSecretDescribedField {
-    key: string;
-    description?: string;
-    example?: string;
-}
-/**
- * Used for secrets that are a single plaintext string,
- * and do not require JSON formating.
- */
-export interface StringSecret extends BaseSecret {
-    type: "string";
-}
-export interface JsonSecret extends BaseSecret {
-    type: "json";
-    fields: (JsonSecretSimpleField | JsonSecretDescribedField)[];
-}
-export type Secret = JsonSecret | StringSecret;
-export interface SecretGroup {
-    accountId: string;
-    region: string;
-    description: string;
-    namePrefix: string;
-    secrets: Secret[];
-}