@capraconsulting/cals-cli 3.11.3 → 3.12.0

package/lib/cache.d.ts

@@ -1,4 +1,4 @@
-import { Config } from "./config";
+import type { Config } from "./config";
 interface CacheItem<T> {
     cacheTime: ReturnType<Date["getTime"]>;
     data: T;

package/lib/cals-cli.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import process$2 from 'node:process';
 import semver from 'semver';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
@@ -6,31 +7,50 @@ import fs from 'node:fs';
 import yaml from 'js-yaml';
 import pMap from 'p-map';
 import AJV from 'ajv';
+import { Buffer } from 'node:buffer';
+import { performance } from 'node:perf_hooks';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
-import keytar from 'keytar';
-import process$2 from 'node:process';
 import * as process$1 from 'process';
-import { performance } from 'perf_hooks';
-import { Buffer } from 'node:buffer';
-import { deprecate } from 'util';
-import path from 'path';
+import keytar from 'keytar';
+import { deprecate } from 'node:util';
+import path from 'node:path';
+import https from 'node:https';
+import os from 'node:os';
 import cachedir from 'cachedir';
-import https from 'https';
-import os from 'os';
+import readline from 'node:readline';
 import chalk from 'chalk';
-import readline from 'readline';
 import { sprintf } from 'sprintf-js';
 import { read } from 'read';
 import { findUp } from 'find-up';
 import { execa } from 'execa';
 
-var version = "3.11.3";
+var version = "3.12.0";
 var engines = {
 	node: ">=12.0.0"
 };
 
+function groupBy(array, iteratee) {
+    return array.reduce((result, item) => {
+        const key = iteratee(item);
+        if (!result[key]) {
+            result[key] = [];
+        }
+        result[key].push(item);
+        return result;
+    }, {});
+}
+function uniq(array) {
+    return Array.from(new Set(array));
+}
+function sortBy(arr, getKey) {
+    return [...arr].sort((a, b) => getKey(a).localeCompare(getKey(b)));
+}
+function sumBy(array, iteratee) {
+    return array.reduce((sum, item) => sum + iteratee(item), 0);
+}
+
 var type = "object";
 var properties = {
 	snyk: {
@@ -325,26 +345,6 @@ var schema = {
 	$schema: $schema
 };
 
-function groupBy(array, iteratee) {
-    return array.reduce((result, item) => {
-        const key = iteratee(item);
-        if (!result[key]) {
-            result[key] = [];
-        }
-        result[key].push(item);
-        return result;
-    }, {});
-}
-function uniq(array) {
-    return Array.from(new Set(array));
-}
-function sortBy(arr, getKey) {
-    return [...arr].sort((a, b) => getKey(a).localeCompare(getKey(b)));
-}
-function sumBy(array, iteratee) {
-    return array.reduce((sum, item) => sum + iteratee(item), 0);
-}
-
 function getTeamId(org, teamName) {
     return `${org}/${teamName}`;
 }
@@ -378,8 +378,7 @@ function requireValidDefinition(definition) {
     }, []);
     // Verify team members exists as users.
     definition.github.teams
-        .map((it) => it.teams)
-        .flat()
+        .flatMap((it) => it.teams)
         .forEach((team) => {
         team.members.forEach((login) => {
             if (!loginList.includes(login)) {
@@ -415,9 +414,7 @@ function requireValidDefinition(definition) {
     });
     // Verify no duplicates in repos.
     definition.projects
-        .flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name)))
-        .flat())
+        .flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name))))
         .reduce((acc, repoName) => {
         if (acc.includes(repoName)) {
             throw new Error(`Duplicate repo: ${repoName}`);
@@ -445,20 +442,18 @@ class DefinitionFile {
 function parseDefinition(value) {
     const result = checkAgainstSchema(yaml.load(value));
     if ("error" in result) {
-        throw new Error("Definition content invalid: " + result.error);
+        throw new Error(`Definition content invalid: ${result.error}`);
     }
     requireValidDefinition(result.definition);
     return result.definition;
 }
 function getRepos(definition) {
-    return definition.projects.flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => ({
+    return definition.projects.flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => ({
         id: getRepoId(org.organization, repo.name),
         orgName: org.organization,
         project,
         repo,
-    })))
-        .flat());
+    }))));
 }
 function getGitHubOrgs(definition) {
     const githubOrganizations = definition.projects.flatMap((project) => project.github.map((it) => it.organization));
@@ -541,9 +536,7 @@ async function undefinedForNotFound(value) {
         if (e.name === "HttpError" && e.status === 404) {
             return undefined;
         }
-        else {
-            throw e;
-        }
+        throw e;
     }
 }
 
@@ -663,11 +656,11 @@ class GitHubService {
             throw new Error(`Response from GitHub not OK (${response.status}): ${await response.text()}`);
         }
         const json = (await response.json());
-        if (!!json.errors) {
+        if (json.errors) {
             throw new Error(`Error from GitHub GraphQL API: ${JSON.stringify(json.errors)}`);
         }
         if (json.data == null) {
-            throw new Error(`No data received from GitHub GraphQL API (unknown reason)`);
+            throw new Error("No data received from GitHub GraphQL API (unknown reason)");
         }
         return json.data;
     }
@@ -1168,8 +1161,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else if (snykProject.origin === "cli" &&
-        snykProject.remoteRepoUrl != null) {
+    if (snykProject.origin === "cli" && snykProject.remoteRepoUrl != null) {
         // The remoteRepoUrl can be overridden when using the CLI, so don't
         // fail if we cannot extract the value.
         const match = /github.com\/([^/]+)\/(.+)\.git$/.exec(snykProject.remoteRepoUrl);
@@ -1181,9 +1173,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else {
-        return undefined;
-    }
+    return undefined;
 }
 function getGitHubRepoId(repo) {
     return repo ? `${repo.owner}/${repo.name}` : undefined;
@@ -1226,7 +1216,7 @@ class CacheProvider {
         const cacheItem = this.mustValidate
             ? undefined
             : this.retrieveJson(cachekey);
-        const expire = new Date(new Date().getTime() - cachetime * 1000).getTime();
+        const expire = new Date(Date.now() - cachetime * 1000).getTime();
         if (cacheItem !== undefined && cacheItem.cacheTime > expire) {
             return cacheItem.data;
         }
@@ -1575,7 +1565,7 @@ function buildGitHubUsersList(definition, members) {
     });
     return reorderListToSimilarAsBefore(definition.github.users, result, (it) => it.login);
 }
-async function dumpSetup(config, reporter, github, snyk, outfile, definitionFile) {
+async function dumpSetup(_config, reporter, github, snyk, outfile, definitionFile) {
     reporter.info("Fetching data. This might take some time");
     const definition = await definitionFile.getDefinition();
     const orgs = await getOrgs(github, getGitHubOrgs(definition));
@@ -1645,7 +1635,7 @@ const command$f = {
         .command(command$h)
         .command(command$g)
         .demandCommand()
-        .usage(`cals definition`),
+        .usage("cals definition"),
     handler: () => {
         yargs(hideBin(process$2.argv)).showHelp();
     },
@@ -1717,7 +1707,7 @@ const command$c = {
             cache: createCacheProvider(config, argv),
         });
         const reporter = createReporter(argv);
-        return analyzeDirectory(reporter, config, github, argv["org"]);
+        return analyzeDirectory(reporter, config, github, argv.org);
     },
 };
 
@@ -2070,27 +2060,28 @@ async function executeChangeSetItem(github, changeItem, reporter, lookup) {
                 username: changeItem.user,
             });
             return true;
-        case "repo-update":
+        case "repo-update": {
             const upd = {
                 owner: changeItem.org,
                 repo: changeItem.repo,
             };
             for (const attrib of changeItem.attribs) {
                 if ("archived" in attrib) {
-                    upd.archived = attrib["archived"];
+                    upd.archived = attrib.archived;
                 }
                 else if ("issues" in attrib) {
-                    upd.has_issues = attrib["issues"];
+                    upd.has_issues = attrib.issues;
                 }
                 else if ("wiki" in attrib) {
-                    upd.has_wiki = attrib["wiki"];
+                    upd.has_wiki = attrib.wiki;
                 }
                 else if ("private" in attrib) {
-                    upd.private = attrib["private"];
+                    upd.private = attrib.private;
                 }
             }
             await github.octokit.repos.update(upd);
             return true;
+        }
         case "repo-team-remove":
             await github.octokit.teams.removeRepoInOrg({
                 org: changeItem.org,
@@ -2135,18 +2126,16 @@ function createOrgGetter(github) {
         }
         return semaphores[orgName];
     }
-    return async function (orgName) {
-        return await getSemaphore(orgName)(async () => {
-            if (!(orgName in orgs)) {
-                const org = await github.getOrg(orgName);
-                orgs[orgName] = {
-                    org,
-                    teams: await github.getTeamList(org),
-                };
-            }
-            return orgs[orgName];
-        });
-    };
+    return async (orgName) => await getSemaphore(orgName)(async () => {
+        if (!(orgName in orgs)) {
+            const org = await github.getOrg(orgName);
+            orgs[orgName] = {
+                org,
+                teams: await github.getTeamList(org),
+            };
+        }
+        return orgs[orgName];
+    });
 }
 async function process(reporter, github, definition, getOrg, execute, limitToOrg) {
     let changes = [];
@@ -2174,16 +2163,16 @@ async function process(reporter, github, definition, getOrg, execute, limitToOrg
     if (ignored.length > 0) {
         reporter.info("Not implemented:");
         for (const change of ignored) {
-            reporter.info("  - " + JSON.stringify(change));
+            reporter.info(`  - ${JSON.stringify(change)}`);
         }
     }
     if (changes.length === 0) {
-        reporter.info(`No actions to be performed`);
+        reporter.info("No actions to be performed");
     }
     else {
-        reporter.info(`To be performed:`);
+        reporter.info("To be performed:");
         for (const change of changes) {
-            reporter.info("  - " + JSON.stringify(change));
+            reporter.info(`  - ${JSON.stringify(change)}`);
         }
     }
     if (execute && changes.length > 0) {
@@ -2224,7 +2213,7 @@ const command$b = {
         const definition = await getDefinitionFile(argv).getDefinition();
         await reportRateLimit(reporter, github, async () => {
             const orgGetter = createOrgGetter(github);
-            await process(reporter, github, definition, orgGetter, !!argv["execute"], argv["org"]);
+            await process(reporter, github, definition, orgGetter, !!argv.execute, argv.org);
         });
     },
 };
@@ -2315,7 +2304,7 @@ const command$a = {
             topic: argv.topic,
             excludeExisting: !!argv["exclude-existing"],
             group: argv.group,
-            org: argv["org"],
+            org: argv.org,
         });
     },
 };
@@ -2324,7 +2313,7 @@ async function listPullRequestsStats({ reporter, github, }) {
     // This is only an initial attempt to get some insights into
     // open pull requests. Feel free to change.
     const pulls = await github.getSearchedPullRequestList("capralifecycle");
-    const cutoffOld = new Date(new Date().getTime() - 86400 * 1000 * 60);
+    const cutoffOld = new Date(Date.now() - 86400 * 1000 * 60);
     const categories = pulls
         .reduce((acc, cur) => {
         const key = `${cur.baseRepository.owner.login}/${cur.baseRepository.name}`;
@@ -2502,13 +2491,13 @@ const command$8 = {
             topic: argv.topic,
             compact: !!argv.compact,
             csv: !!argv.csv,
-            org: argv["org"],
+            org: argv.org,
         });
     },
 };
 
 const e = encodeURIComponent;
-async function listWebhooks(reporter, cache, github, org) {
+async function listWebhooks(reporter, _cache, github, org) {
     const repos = (await github.getOrgRepoList({ org })).filter((it) => !it.isArchived);
     for (const repo of repos) {
         reporter.log("");
@@ -2549,7 +2538,7 @@ const command$7 = {
     handler: async (argv) => {
         const config = createConfig();
         const cacheProvider = createCacheProvider(config, argv);
-        await listWebhooks(createReporter(argv), cacheProvider, await createGitHubService({ config, cache: cacheProvider }), argv["org"]);
+        await listWebhooks(createReporter(argv), cacheProvider, await createGitHubService({ config, cache: cacheProvider }), argv.org);
     },
 };
 
@@ -2605,7 +2594,7 @@ function parseShortlogSummary(value) {
     const matches = [...value.matchAll(/^\s*(\d+)\s+(.+)$/gm)];
     return matches.map((it) => ({
         name: it[2],
-        count: parseInt(it[1]),
+        count: Number.parseInt(it[1]),
     }));
 }
 
@@ -2771,9 +2760,7 @@ function formatAuthorAndCount(reporter, name, count) {
     if (isBotAuthor(name)) {
         return reporter.format.grey(text);
     }
-    else {
-        return reporter.format.greenBright(text);
-    }
+    return reporter.format.greenBright(text);
 }
 async function updateRepos(reporter, foundRepos) {
     const updateResults = await updateReposInParallel(reporter, foundRepos);
@@ -2860,12 +2847,12 @@ function getExpectedRepo(item) {
 }
 function getGitRepo(rootdir, relpath) {
     return new GitRepo(path.resolve(rootdir, relpath), async (result) => {
-        await appendFile(path.resolve(rootdir, CALS_LOG), JSON.stringify({
+        await appendFile(path.resolve(rootdir, CALS_LOG), `${JSON.stringify({
             time: new Date().toISOString(),
             context: relpath,
             type: "exec-result",
             payload: result,
-        }) + "\n");
+        })}\n`);
     });
 }
 function getDefinitionRepo(rootdir, reposInOrg, cals) {
@@ -3089,7 +3076,8 @@ const command$5 = {
         .option("ask-move", {
         describe: "Ask to actual move renamed repos",
         type: "boolean",
-    }).usage(`cals github sync
+    })
+        .usage(`cals github sync
 
 Synchronize all checked out GitHub repositories within the working directory
 grouped by the project in the resource definition file. The command can also
@@ -3157,7 +3145,8 @@ const command$4 = {
         .command(command$7)
         .command(command$6)
         .command(command$5)
-        .demandCommand().usage(`cals github
+        .demandCommand()
+        .usage(`cals github
 
 Notes:
   Before doing anything against GitHub you need to configure a token
@@ -3311,7 +3300,11 @@ const command$1 = {
 const command = {
     command: "snyk",
     describe: "Integration with Snyk",
-    builder: (yargs) => yargs.command(command$2).command(command$3).command(command$1).demandCommand()
+    builder: (yargs) => yargs
+        .command(command$2)
+        .command(command$3)
+        .command(command$1)
+        .demandCommand()
         .usage(`cals snyk
 
 Notes:
@@ -3330,7 +3323,7 @@ async function main() {
         process$2.exit(1);
     }
     await yargs(hideBin(process$2.argv))
-        .usage(`cals-cli v${version} (build: ${"2025-06-10T07:40:59+0000"})`)
+        .usage(`cals-cli v${version} (build: ${"2025-07-01T10:17:26+0000"})`)
         .scriptName("cals")
         .locale("en")
         .help("help")

package/lib/cals-cli.mjs.map

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

package/lib/cli/commands/definition/dump-setup.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/definition/validate.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/definition.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import { type CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/delete-cache.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/getting-started.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/analyze-directory.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/configure.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/generate-clone-commands.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import { type CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/list-pull-requests-stats.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/list-repos.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/list-webhooks.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/set-token.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/github/sync.d.ts

@@ -1,5 +1,5 @@
-import { CommandModule } from "yargs";
-import { DefinitionRepo } from "../../../definition/types";
+import type { CommandModule } from "yargs";
+import type { DefinitionRepo } from "../../../definition/types";
 interface Alias {
     group: string;
     name: string;

package/lib/cli/commands/github/util.d.ts

@@ -1,3 +1,3 @@
-import { GitHubService } from "../../../github";
-import { Reporter } from "../../reporter";
+import type { GitHubService } from "../../../github";
+import type { Reporter } from "../../reporter";
 export declare function reportRateLimit(reporter: Reporter, github: GitHubService, block: () => Promise<void>): Promise<void>;

package/lib/cli/commands/github.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import { type CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/snyk/report.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/snyk/set-token.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/snyk/sync.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/snyk.d.ts

@@ -1,3 +1,3 @@
-import { CommandModule } from "yargs";
+import { type CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/util.d.ts

@@ -1,4 +1,4 @@
-import { Arguments, Options } from "yargs";
+import type { Arguments, Options } from "yargs";
 import { CacheProvider } from "../cache";
 import { Config } from "../config";
 import { DefinitionFile } from "../definition";

package/lib/config.d.ts

@@ -1,4 +1,4 @@
-import https from "https";
+import https from "node:https";
 export declare class Config {
     cwd: string;
     configFile: string;

package/lib/definition/definition.d.ts

@@ -1,5 +1,5 @@
 import schema from "../definition-schema.json";
-import { Definition, GetReposResponse } from "./types";
+import type { Definition, GetReposResponse } from "./types";
 export { schema };
 export declare function getRepoId(orgName: string, repoName: string): string;
 export declare class DefinitionFile {

package/lib/definition/types.d.ts

@@ -1,4 +1,4 @@
-import { Permission } from "../github/types";
+import type { Permission } from "../github/types";
 export interface Definition {
     snyk?: {
         accountId: string;

package/lib/github/changeset/changeset.d.ts

@@ -1,7 +1,7 @@
-import { Definition } from "../../definition/types";
-import { GitHubService } from "../service";
-import { OrgsGetResponse } from "../types";
-import { ChangeSetItem } from "./types";
+import type { Definition } from "../../definition/types";
+import type { GitHubService } from "../service";
+import type { OrgsGetResponse } from "../types";
+import type { ChangeSetItem } from "./types";
 /**
  * Generate change set items for projects.
  */

package/lib/github/changeset/execute.d.ts

@@ -1,6 +1,6 @@
-import { Reporter } from "../../cli/reporter";
-import { GitHubService } from "../service";
-import { ChangeSetItem, RepoCreateItem } from "./types";
+import type { Reporter } from "../../cli/reporter";
+import type { GitHubService } from "../service";
+import type { ChangeSetItem, RepoCreateItem } from "./types";
 type NotImplementedChangeSetItem = RepoCreateItem;
 export declare function isNotImplementedChangeSetItem(changeItem: ChangeSetItem): changeItem is NotImplementedChangeSetItem;
 /**

package/lib/github/changeset/types.d.ts

@@ -1,4 +1,4 @@
-import { Permission } from "../types";
+import type { Permission } from "../types";
 export interface RepoCreateItem {
     type: "repo-create";
     org: string;

package/lib/github/index.d.ts

@@ -1,3 +1,3 @@
-export { createGitHubService, GitHubService } from "./service";
 export type { SearchedPullRequestListItem } from "./service";
+export { createGitHubService, GitHubService } from "./service";
 export type { RenovateDependencyDashboardIssue, VulnerabilityAlert, } from "./types";

package/lib/github/service.d.ts

@@ -1,8 +1,8 @@
 import { Octokit } from "@octokit/rest";
-import { CacheProvider } from "../cache";
-import { Config } from "../config";
-import { GitHubTokenProvider } from "./token";
-import { OrgMemberOrInvited, OrgsGetResponse, OrgsListMembersResponseItem, OrgsListPendingInvitationsResponseItem, RenovateDependencyDashboardIssue, Repo, ReposGetResponse, ReposListHooksResponseItem, ReposListTeamsResponseItem, TeamMemberOrInvited, TeamsListMembersResponseItem, TeamsListPendingInvitationsResponseItem, TeamsListResponseItem, VulnerabilityAlert } from "./types";
+import type { CacheProvider } from "../cache";
+import type { Config } from "../config";
+import { type GitHubTokenProvider } from "./token";
+import type { OrgMemberOrInvited, OrgsGetResponse, OrgsListMembersResponseItem, OrgsListPendingInvitationsResponseItem, RenovateDependencyDashboardIssue, Repo, ReposGetResponse, ReposListHooksResponseItem, ReposListTeamsResponseItem, TeamMemberOrInvited, TeamsListMembersResponseItem, TeamsListPendingInvitationsResponseItem, TeamsListResponseItem, VulnerabilityAlert } from "./types";
 interface SearchedPullRequestListQueryResult {
     search: {
         pageInfo: {

package/lib/github/types.d.ts

@@ -1,4 +1,4 @@
-import { Endpoints } from "@octokit/types";
+import type { Endpoints } from "@octokit/types";
 export type OrgsGetResponse = Endpoints["GET /orgs/{org}"]["response"]["data"];
 export type OrgsListMembersResponseItem = Exclude<Endpoints["GET /orgs/{org}/members"]["response"]["data"][0], null>;
 export type OrgsListPendingInvitationsResponseItem = Endpoints["GET /orgs/{org}/invitations"]["response"]["data"][0];

package/lib/github/util.d.ts

@@ -1,4 +1,4 @@
-import { Repo } from "./types";
+import type { Repo } from "./types";
 export declare function getGroup(repo: Repo): string | null;
 export declare function getGroupedRepos(repos: Repo[]): {
     name: string;

package/lib/index.es.js

@@ -1,27 +1,27 @@
 import fs from 'node:fs';
-import path from 'path';
-import chalk from 'chalk';
-import readline from 'readline';
+import path from 'node:path';
 import process$1 from 'node:process';
-import 'util';
+import readline from 'node:readline';
+import chalk from 'chalk';
+import 'node:util';
+import https from 'node:https';
+import os from 'node:os';
 import cachedir from 'cachedir';
-import https from 'https';
-import os from 'os';
 import AJV from 'ajv';
 import yaml from 'js-yaml';
+import { Buffer } from 'node:buffer';
+import { performance } from 'node:perf_hooks';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
-import keytar from 'keytar';
 import * as process from 'process';
-import { performance } from 'perf_hooks';
-import { Buffer } from 'node:buffer';
-import { strict } from 'assert';
+import keytar from 'keytar';
+import { strict } from 'node:assert';
+import { Transform } from 'node:stream';
 import { execa } from 'execa';
 import { read } from 'read';
-import { Transform } from 'stream';
 
-var version = "3.11.3";
+var version = "3.12.0";
 
 class CacheProvider {
     constructor(config) {
@@ -60,7 +60,7 @@ class CacheProvider {
         const cacheItem = this.mustValidate
             ? undefined
             : this.retrieveJson(cachekey);
-        const expire = new Date(new Date().getTime() - cachetime * 1000).getTime();
+        const expire = new Date(Date.now() - cachetime * 1000).getTime();
         if (cacheItem !== undefined && cacheItem.cacheTime > expire) {
             return cacheItem.data;
         }
@@ -159,6 +159,10 @@ class Config {
     }
 }
 
+function uniq(array) {
+    return Array.from(new Set(array));
+}
+
 var type = "object";
 var properties = {
 	snyk: {
@@ -453,10 +457,6 @@ var schema = {
 	$schema: $schema
 };
 
-function uniq(array) {
-    return Array.from(new Set(array));
-}
-
 function getTeamId(org, teamName) {
     return `${org}/${teamName}`;
 }
@@ -490,8 +490,7 @@ function requireValidDefinition(definition) {
     }, []);
     // Verify team members exists as users.
     definition.github.teams
-        .map((it) => it.teams)
-        .flat()
+        .flatMap((it) => it.teams)
         .forEach((team) => {
         team.members.forEach((login) => {
             if (!loginList.includes(login)) {
@@ -527,9 +526,7 @@ function requireValidDefinition(definition) {
     });
     // Verify no duplicates in repos.
     definition.projects
-        .flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name)))
-        .flat())
+        .flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name))))
         .reduce((acc, repoName) => {
         if (acc.includes(repoName)) {
             throw new Error(`Duplicate repo: ${repoName}`);
@@ -557,20 +554,18 @@ class DefinitionFile {
 function parseDefinition(value) {
     const result = checkAgainstSchema(yaml.load(value));
     if ("error" in result) {
-        throw new Error("Definition content invalid: " + result.error);
+        throw new Error(`Definition content invalid: ${result.error}`);
     }
     requireValidDefinition(result.definition);
     return result.definition;
 }
 function getRepos(definition) {
-    return definition.projects.flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => ({
+    return definition.projects.flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => ({
         id: getRepoId(org.organization, repo.name),
         orgName: org.organization,
         project,
         repo,
-    })))
-        .flat());
+    }))));
 }
 function getGitHubOrgs(definition) {
     const githubOrganizations = definition.projects.flatMap((project) => project.github.map((it) => it.organization));
@@ -624,9 +619,7 @@ async function undefinedForNotFound(value) {
         if (e.name === "HttpError" && e.status === 404) {
             return undefined;
         }
-        else {
-            throw e;
-        }
+        throw e;
     }
 }
 
@@ -746,11 +739,11 @@ class GitHubService {
             throw new Error(`Response from GitHub not OK (${response.status}): ${await response.text()}`);
         }
         const json = (await response.json());
-        if (!!json.errors) {
+        if (json.errors) {
             throw new Error(`Error from GitHub GraphQL API: ${JSON.stringify(json.errors)}`);
         }
         if (json.data == null) {
-            throw new Error(`No data received from GitHub GraphQL API (unknown reason)`);
+            throw new Error("No data received from GitHub GraphQL API (unknown reason)");
         }
         return json.data;
     }
@@ -1257,8 +1250,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else if (snykProject.origin === "cli" &&
-        snykProject.remoteRepoUrl != null) {
+    if (snykProject.origin === "cli" && snykProject.remoteRepoUrl != null) {
         // The remoteRepoUrl can be overridden when using the CLI, so don't
         // fail if we cannot extract the value.
         const match = /github.com\/([^/]+)\/(.+)\.git$/.exec(snykProject.remoteRepoUrl);
@@ -1270,9 +1262,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else {
-        return undefined;
-    }
+    return undefined;
 }
 function getGitHubRepoId(repo) {
     return repo ? `${repo.owner}/${repo.name}` : undefined;
@@ -1429,7 +1419,7 @@ class TestExecutor {
             process$1.exitCode = 1;
         }
         finally {
-            console.log(`Reached finally block`);
+            console.log("Reached finally block");
             this.usingWithCleanupTasks = false;
             if (this.cleanupTask == null) {
                 this.cleanupTask = this.runTasks();
@@ -1448,8 +1438,8 @@ function createTestExecutor() {
  * Gives a value formatted as "yyyymmdd-xxxxxx", e.g. "20200523-3f2c87".
  */
 function generateRunId() {
-    const low = parseInt("100000", 16);
-    const high = parseInt("ffffff", 16);
+    const low = 0x100000;
+    const high = 0xffffff;
     const range = high - low + 1;
     const now = new Date();
     return [
@@ -1610,7 +1600,7 @@ class OutputPrefixTransform extends Transform {
                 if (result.endsWith("\n\u001B[0m")) {
                     result = result.slice(0, -5) + result.slice(-4);
                 }
-                result = prefix + result.replace(/\n/g, `\n${prefix}`) + "\n";
+                result = `${prefix + result.replace(/\n/g, `\n${prefix}`)}\n`;
                 callback(null, result);
             },
         });
@@ -1739,7 +1729,7 @@ async function startContainer({ executor, network, imageId, alias, env, dockerAr
     executor.registerCleanupTask(async () => {
         console.log(`Stopping container ${containerName}`);
         const r = execa("docker", ["stop", containerName]);
-        pipeToConsole(r, (alias ?? containerName) + " (stop)");
+        pipeToConsole(r, `${alias ?? containerName} (stop)`);
         try {
             await r;
         }

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,27 +1,27 @@
 import fs from 'node:fs';
-import path from 'path';
-import chalk from 'chalk';
-import readline from 'readline';
+import path from 'node:path';
 import process$1 from 'node:process';
-import 'util';
+import readline from 'node:readline';
+import chalk from 'chalk';
+import 'node:util';
+import https from 'node:https';
+import os from 'node:os';
 import cachedir from 'cachedir';
-import https from 'https';
-import os from 'os';
 import AJV from 'ajv';
 import yaml from 'js-yaml';
+import { Buffer } from 'node:buffer';
+import { performance } from 'node:perf_hooks';
 import { Octokit } from '@octokit/rest';
 import fetch from 'node-fetch';
 import pLimit from 'p-limit';
-import keytar from 'keytar';
 import * as process from 'process';
-import { performance } from 'perf_hooks';
-import { Buffer } from 'node:buffer';
-import { strict } from 'assert';
+import keytar from 'keytar';
+import { strict } from 'node:assert';
+import { Transform } from 'node:stream';
 import { execa } from 'execa';
 import { read } from 'read';
-import { Transform } from 'stream';
 
-var version = "3.11.3";
+var version = "3.12.0";
 
 class CacheProvider {
     constructor(config) {
@@ -60,7 +60,7 @@ class CacheProvider {
         const cacheItem = this.mustValidate
             ? undefined
             : this.retrieveJson(cachekey);
-        const expire = new Date(new Date().getTime() - cachetime * 1000).getTime();
+        const expire = new Date(Date.now() - cachetime * 1000).getTime();
         if (cacheItem !== undefined && cacheItem.cacheTime > expire) {
             return cacheItem.data;
         }
@@ -159,6 +159,10 @@ class Config {
     }
 }
 
+function uniq(array) {
+    return Array.from(new Set(array));
+}
+
 var type = "object";
 var properties = {
 	snyk: {
@@ -453,10 +457,6 @@ var schema = {
 	$schema: $schema
 };
 
-function uniq(array) {
-    return Array.from(new Set(array));
-}
-
 function getTeamId(org, teamName) {
     return `${org}/${teamName}`;
 }
@@ -490,8 +490,7 @@ function requireValidDefinition(definition) {
     }, []);
     // Verify team members exists as users.
     definition.github.teams
-        .map((it) => it.teams)
-        .flat()
+        .flatMap((it) => it.teams)
         .forEach((team) => {
         team.members.forEach((login) => {
             if (!loginList.includes(login)) {
@@ -527,9 +526,7 @@ function requireValidDefinition(definition) {
     });
     // Verify no duplicates in repos.
     definition.projects
-        .flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name)))
-        .flat())
+        .flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => getRepoId(org.organization, repo.name))))
         .reduce((acc, repoName) => {
         if (acc.includes(repoName)) {
             throw new Error(`Duplicate repo: ${repoName}`);
@@ -557,20 +554,18 @@ class DefinitionFile {
 function parseDefinition(value) {
     const result = checkAgainstSchema(yaml.load(value));
     if ("error" in result) {
-        throw new Error("Definition content invalid: " + result.error);
+        throw new Error(`Definition content invalid: ${result.error}`);
     }
     requireValidDefinition(result.definition);
     return result.definition;
 }
 function getRepos(definition) {
-    return definition.projects.flatMap((project) => project.github
-        .map((org) => (org.repos || []).map((repo) => ({
+    return definition.projects.flatMap((project) => project.github.flatMap((org) => (org.repos || []).map((repo) => ({
         id: getRepoId(org.organization, repo.name),
         orgName: org.organization,
         project,
         repo,
-    })))
-        .flat());
+    }))));
 }
 function getGitHubOrgs(definition) {
     const githubOrganizations = definition.projects.flatMap((project) => project.github.map((it) => it.organization));
@@ -624,9 +619,7 @@ async function undefinedForNotFound(value) {
         if (e.name === "HttpError" && e.status === 404) {
             return undefined;
         }
-        else {
-            throw e;
-        }
+        throw e;
     }
 }
 
@@ -746,11 +739,11 @@ class GitHubService {
             throw new Error(`Response from GitHub not OK (${response.status}): ${await response.text()}`);
         }
         const json = (await response.json());
-        if (!!json.errors) {
+        if (json.errors) {
             throw new Error(`Error from GitHub GraphQL API: ${JSON.stringify(json.errors)}`);
         }
         if (json.data == null) {
-            throw new Error(`No data received from GitHub GraphQL API (unknown reason)`);
+            throw new Error("No data received from GitHub GraphQL API (unknown reason)");
         }
         return json.data;
     }
@@ -1257,8 +1250,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else if (snykProject.origin === "cli" &&
-        snykProject.remoteRepoUrl != null) {
+    if (snykProject.origin === "cli" && snykProject.remoteRepoUrl != null) {
         // The remoteRepoUrl can be overridden when using the CLI, so don't
         // fail if we cannot extract the value.
         const match = /github.com\/([^/]+)\/(.+)\.git$/.exec(snykProject.remoteRepoUrl);
@@ -1270,9 +1262,7 @@ function getGitHubRepo(snykProject) {
             name: match[2],
         };
     }
-    else {
-        return undefined;
-    }
+    return undefined;
 }
 function getGitHubRepoId(repo) {
     return repo ? `${repo.owner}/${repo.name}` : undefined;
@@ -1429,7 +1419,7 @@ class TestExecutor {
             process$1.exitCode = 1;
         }
         finally {
-            console.log(`Reached finally block`);
+            console.log("Reached finally block");
             this.usingWithCleanupTasks = false;
             if (this.cleanupTask == null) {
                 this.cleanupTask = this.runTasks();
@@ -1448,8 +1438,8 @@ function createTestExecutor() {
  * Gives a value formatted as "yyyymmdd-xxxxxx", e.g. "20200523-3f2c87".
  */
 function generateRunId() {
-    const low = parseInt("100000", 16);
-    const high = parseInt("ffffff", 16);
+    const low = 0x100000;
+    const high = 0xffffff;
     const range = high - low + 1;
     const now = new Date();
     return [
@@ -1610,7 +1600,7 @@ class OutputPrefixTransform extends Transform {
                 if (result.endsWith("\n\u001B[0m")) {
                     result = result.slice(0, -5) + result.slice(-4);
                 }
-                result = prefix + result.replace(/\n/g, `\n${prefix}`) + "\n";
+                result = `${prefix + result.replace(/\n/g, `\n${prefix}`)}\n`;
                 callback(null, result);
             },
         });
@@ -1739,7 +1729,7 @@ async function startContainer({ executor, network, imageId, alias, env, dockerAr
     executor.registerCleanupTask(async () => {
         console.log(`Stopping container ${containerName}`);
         const r = execa("docker", ["stop", containerName]);
-        pipeToConsole(r, (alias ?? containerName) + " (stop)");
+        pipeToConsole(r, `${alias ?? containerName} (stop)`);
         try {
             await r;
         }

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/lib/snyk/service.d.ts

@@ -1,7 +1,7 @@
-import { Config } from "../config";
-import { Definition } from "../definition";
-import { SnykTokenProvider } from "./token";
-import { SnykProject } from "./types";
+import type { Config } from "../config";
+import type { Definition } from "../definition";
+import { type SnykTokenProvider } from "./token";
+import type { SnykProject } from "./types";
 interface SnykServiceProps {
     config: Config;
     tokenProvider: SnykTokenProvider;

package/lib/snyk/util.d.ts

@@ -1,3 +1,3 @@
-import { SnykGitHubRepo, SnykProject } from "./types";
+import type { SnykGitHubRepo, SnykProject } from "./types";
 export declare function getGitHubRepo(snykProject: SnykProject): SnykGitHubRepo | undefined;
 export declare function getGitHubRepoId(repo: SnykGitHubRepo | undefined): string | undefined;

package/lib/sonarcloud/index.d.ts

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

package/lib/sonarcloud/service.d.ts

@@ -1,5 +1,5 @@
-import { Config } from "../config";
-import { SonarCloudTokenProvider } from "./token";
+import type { Config } from "../config";
+import { type SonarCloudTokenProvider } from "./token";
 interface SonarCloudServiceProps {
     config: Config;
     tokenProvider: SonarCloudTokenProvider;

package/lib/testing/lib.d.ts

@@ -1,5 +1,5 @@
 import { type Subprocess } from "execa";
-import { TestExecutor } from "./executor";
+import type { TestExecutor } from "./executor";
 export interface Container {
     id: string;
     name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capraconsulting/cals-cli",
-  "version": "3.11.3",
+  "version": "3.12.0",
   "description": "CLI for repeatable tasks in CALS",
   "type": "module",
   "license": "Apache-2.0",
@@ -9,10 +9,10 @@
     "build": "rollup -c",
     "test": "vitest run --coverage src",
     "test:watch": "vitest --coverage src",
-    "lint": "eslint .",
-    "lint:fix": "eslint --fix .",
+    "lint": "biome check",
+    "lint:fix": "biome check --fix",
+    "format": "biome format --write",
     "prepack": "./scripts/build-and-verify.sh",
-    "prettier": "prettier --config .prettierrc --write .",
     "semantic-release": "semantic-release",
     "watch": "rollup -c -w"
   },
@@ -23,7 +23,7 @@
     "cals": "lib/cals-cli.mjs"
   },
   "dependencies": {
-    "@octokit/rest": "^21.1.1",
+    "@octokit/rest": "^22.0.0",
     "@types/dateformat": "5.0.3",
     "ajv": "^8.11.0",
     "cachedir": "^2.4.0",
@@ -43,43 +43,36 @@
   },
   "overrides": {
     "semantic-release": {
-      "@semantic-release/npm": "12.0.1"
+      "@semantic-release/npm": "12.0.2"
     }
   },
   "devDependencies": {
+    "@biomejs/biome": "2.0.6",
     "@commitlint/cli": "19.8.1",
     "@commitlint/config-conventional": "19.8.1",
-    "@eslint/eslintrc": "^3.2.0",
-    "@eslint/js": "^9.16.0",
     "@octokit/types": "14.1.0",
     "@rollup/plugin-alias": "5.1.1",
     "@rollup/plugin-json": "6.1.0",
     "@rollup/plugin-replace": "6.0.2",
     "@types/js-yaml": "4.0.9",
     "@types/lodash-es": "4.17.12",
-    "@types/node": "22.15.30",
+    "@types/node": "24.0.8",
     "@types/node-fetch": "2.6.12",
     "@types/read": "0.0.32",
     "@types/semver": "7.7.0",
     "@types/sprintf-js": "1.1.4",
     "@types/yargs": "17.0.33",
-    "@typescript-eslint/eslint-plugin": "8.33.1",
-    "@typescript-eslint/parser": "8.33.1",
-    "@vitest/coverage-v8": "3.2.2",
-    "@vitest/ui": "3.2.2",
+    "@vitest/coverage-v8": "3.2.4",
+    "@vitest/ui": "3.2.4",
     "dateformat": "5.0.3",
-    "eslint": "9.28.0",
-    "eslint-config-prettier": "10.1.5",
-    "eslint-plugin-prettier": "5.4.1",
     "husky": "9.1.7",
-    "prettier": "3.5.3",
-    "rollup": "4.42.0",
+    "rollup": "4.44.1",
     "rollup-plugin-typescript2": "0.36.0",
-    "semantic-release": "24.2.5",
-    "tsx": "4.19.4",
+    "semantic-release": "24.2.6",
+    "tsx": "4.20.3",
     "typescript": "5.8.3",
     "typescript-json-schema": "0.65.1",
-    "vitest": "3.2.2"
+    "vitest": "3.2.4"
   },
   "files": [
     "lib"