apify-test-tools 0.10.1-beta.3 → 0.10.1-beta.5

package/bin/git.ts

@@ -1,5 +1,6 @@
+import { logger } from './logger.js';
 import type { Commit, Config } from './types.js';
-import { spawnCommand } from './utils.js';
+import { GitCommandError, runGitCommand } from './utils.js';
 
 export const GIT_FORMAT_SEPARATOR = '»¦«';
 const GIT_LOG_FORMAT = ['%H', '%aN<%aE>', '%aD', '%s'].join(GIT_FORMAT_SEPARATOR);
@@ -7,19 +8,20 @@ const GIT_LOG_FORMAT = ['%H', '%aN<%aE>', '%aD', '%s'].join(GIT_FORMAT_SEPARATOR
 /**
  * Gets the list of changed files between the given commits (inclusive).
  */
-export const getChangedFiles = (commits: Commit[]) => {
+export const getChangedFiles = async (commits: Commit[]) => {
     // getCommits never returns an empty list (the rerun check returns all commits when the base commit
     // is the branch HEAD, and an empty git range throws when parsing), so this signals a programmer error
     if (commits.length === 0) {
         throw new Error('Cannot get changed files: the commit list is empty. This should never happen.');
     }
 
-    const changedFilesString = spawnCommand(
-        `git diff --name-only ${commits[0].sha}~..${commits[commits.length - 1].sha}`,
+    const changedFilesString = await runGitCommand(
+        ['diff', '--name-only', `${commits[0].sha}~..${commits[commits.length - 1].sha}`],
+        { operation: 'get the list of changed files between commits' },
     );
 
     const changedFiles = changedFilesString.split('\n').filter(Boolean);
-    console.error(`Changed files (up to 50): ${changedFiles.slice(0, 50).join(', ')}`);
+    logger.info(`Changed files (up to 50): ${changedFiles.slice(0, 50).join(', ')}`);
     return changedFiles;
 };
 
@@ -28,17 +30,36 @@ export const getChangedFiles = (commits: Commit[]) => {
  * (i.e. a genuine "merge from target" commit, not a merge of some unrelated branch).
  * Uses the full targetBranch..sourceBranch range, ignoring baseCommit.
  */
-export const hasMergeFromTarget = (sourceBranch: string, targetBranch: string): boolean => {
-    const mergeShas = spawnCommand(`git log --merges --pretty=format:%H ${targetBranch}..${sourceBranch}`)
+export const hasMergeFromTarget = async (sourceBranch: string, targetBranch: string): Promise<boolean> => {
+    const mergeShas = (
+        await runGitCommand(['log', '--merges', '--pretty=format:%H', `${targetBranch}..${sourceBranch}`], {
+            operation: 'find merge commits on the source branch that are absent from the target branch',
+        })
+    )
         .split('\n')
         .filter(Boolean);
 
     for (const sha of mergeShas) {
-        const parents = spawnCommand(`git log -1 --pretty=format:%P ${sha}`).trim().split(' ');
+        const parents = (
+            await runGitCommand(['log', '-1', '--pretty=format:%P', sha], {
+                operation: 'get parents of a merge commit',
+            })
+        ).split(' ');
         for (const parent of parents) {
             // git merge-base A B outputs the common ancestor.
             // If that equals A, then A is an ancestor of B (i.e. parent is reachable from targetBranch).
-            const mergeBase = spawnCommand(`git merge-base ${parent} ${targetBranch}`);
+            let mergeBase: string;
+            try {
+                mergeBase = await runGitCommand(['merge-base', parent, targetBranch], {
+                    operation: 'check whether a merge parent is reachable from the target branch',
+                });
+            } catch (error) {
+                // Exit code 1 on merge-base means the histories have no common ancestor.
+                if (error instanceof GitCommandError && error.exitCode === 1) {
+                    continue;
+                }
+                throw error;
+            }
             if (mergeBase === parent) {
                 return true;
             }
@@ -51,8 +72,11 @@ export const hasMergeFromTarget = (sourceBranch: string, targetBranch: string):
  * Returns all files touched by non-merge commits on the branch (full history, ignoring baseCommit).
  * Used to check whether the branch itself has any functional changes, independent of what master merged in.
  */
-export const getBranchOnlyChangedFiles = (sourceBranch: string, targetBranch: string): string[] => {
-    const output = spawnCommand(`git log --no-merges --name-only --pretty=format: ${targetBranch}..${sourceBranch}`);
+export const getBranchOnlyChangedFiles = async (sourceBranch: string, targetBranch: string): Promise<string[]> => {
+    const output = await runGitCommand(
+        ['log', '--no-merges', '--name-only', '--pretty=format:', `${targetBranch}..${sourceBranch}`],
+        { operation: 'list files changed by non-merge commits on the source branch' },
+    );
     return output.split('\n').filter(Boolean);
 };
 
@@ -79,10 +103,12 @@ export const parseBaseCommit = (shaOrCommit: string | undefined): string | undef
     return sha;
 };
 
-const fetchAllBranchCommits = (sourceBranch: string, targetBranch: string): Commit[] => {
-    const commitsStrings = spawnCommand(
-        `git log --pretty=format:'${GIT_LOG_FORMAT}' ${targetBranch}..${sourceBranch}`,
-    ).split('\n');
+const fetchAllBranchCommits = async (sourceBranch: string, targetBranch: string): Promise<Commit[]> => {
+    const output = await runGitCommand(
+        ['log', `--pretty=format:${GIT_LOG_FORMAT}`, `${targetBranch}..${sourceBranch}`],
+        { operation: 'list commits reachable from the source ref but absent from the target ref' },
+    );
+    const commitsStrings = output.split('\n');
     const commits = commitsStrings.map((commitString) => parseCommit(commitString));
     commits.reverse();
     return commits;
@@ -92,22 +118,22 @@ const fetchAllBranchCommits = (sourceBranch: string, targetBranch: string): Comm
  * Gets the commits between sourceBranch and targetBranch (exclusive).
  * - If baseCommit is provided, only returns commits after the baseCommit.
  */
-export const getCommits = ({
+export const getCommits = async ({
     sourceBranch,
     targetBranch,
     baseCommit,
-}: Pick<Config, 'sourceBranch' | 'targetBranch' | 'baseCommit'>): Commit[] => {
+}: Pick<Config, 'sourceBranch' | 'targetBranch' | 'baseCommit'>): Promise<Commit[]> => {
     const baseCommitSha = parseBaseCommit(baseCommit);
-    const commits = fetchAllBranchCommits(sourceBranch, targetBranch);
+    const commits = await fetchAllBranchCommits(sourceBranch, targetBranch);
 
     // The last validated (base) commit being the branch HEAD means nothing new was pushed since the last
     // validation — the dev reran the workflow (or force-pushed to the same state) to trigger a clean test
     const headSha = commits[commits.length - 1]?.sha;
     if (baseCommitSha !== undefined && baseCommitSha === headSha) {
-        console.error(
+        logger.info(
             `Detected rerun with the same commit that we already validated. This usually means the user wants to rerun the Action from scratch, ignoring last validated commit ${baseCommitSha} and returning all commits`,
         );
-        console.error(`Commits being returned: ${commits.map((c) => c.sha).join(', ')}`);
+        logger.info(`Commits being returned: ${commits.map((c) => c.sha).join(', ')}`);
         return commits;
     }
 
@@ -116,17 +142,15 @@ export const getCommits = ({
     const hasBaseCommit = baseCommitIndex !== -1;
     if (hasBaseCommit) {
         const commitsUpToBaseCommit = commits.slice(baseCommitIndex + 1);
-        console.error(
+        logger.info(
             `Found base commit ${baseCommitSha} at index ${baseCommitIndex}, returning ${commitsUpToBaseCommit.length} commits after it`,
         );
-        console.error(`Commits being returned: ${commitsUpToBaseCommit.map((c) => c.sha).join(', ')}`);
+        logger.info(`Commits being returned: ${commitsUpToBaseCommit.map((c) => c.sha).join(', ')}`);
         return commitsUpToBaseCommit;
     }
 
-    console.error(
-        `Base commit ${baseCommitSha} not found in the commit range, returning all ${commits.length} commits`,
-    );
-    console.error(`Commits being returned: ${commits.map((c) => c.sha).join(', ')}`);
+    logger.info(`Base commit ${baseCommitSha} not found in the commit range, returning all ${commits.length} commits`);
+    logger.info(`Commits being returned: ${commits.map((c) => c.sha).join(', ')}`);
     return commits;
 };
 
@@ -148,8 +172,10 @@ export const parseCommit = (commitString: string): Commit => {
  * Returns the currently checked-out branch. Release builds point the Actor version at this branch,
  * so a detached HEAD (no branch to point at) is an error rather than a guess.
  */
-export const getCurrentBranch = (): string => {
-    const branch = spawnCommand('git rev-parse --abbrev-ref HEAD');
+export const getCurrentBranch = async (): Promise<string> => {
+    const branch = await runGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], {
+        operation: 'determine the current branch for release',
+    });
     if (branch === 'HEAD') {
         throw new Error(
             'Cannot determine the branch to release: HEAD is detached. Check out the branch you want to release.',
@@ -162,8 +188,11 @@ export const getCurrentBranch = (): string => {
  * Reads the repository URL from the `origin` remote, rewritten to the SSH form the Apify platform
  * uses for Git repo sources, e.g. git@github.com:apify-store/google-maps
  */
-const getOriginRepoUrl = (): string => {
-    return spawnCommand('git remote get-url origin').replace(/^https:\/\/github\.com\//, 'git@github.com:');
+const getOriginRepoUrl = async (): Promise<string> => {
+    const rawUrl = await runGitCommand(['remote', 'get-url', 'origin'], {
+        operation: 'read the origin repository URL',
+    });
+    return rawUrl.replace(/^https:\/\/github\.com\//, 'git@github.com:');
 };
 
 /**
@@ -171,8 +200,8 @@ const getOriginRepoUrl = (): string => {
  * each Actor's default version, so a fork or mirror remote can't repoint a published Actor. An explicit
  * --repo-url skips that check: passing it is how you move an Actor to another repository on purpose.
  */
-export const resolveRepoUrl = (explicitRepoUrl: string | undefined) => ({
-    repoUrl: explicitRepoUrl ?? getOriginRepoUrl(),
+export const resolveRepoUrl = async (explicitRepoUrl: string | undefined) => ({
+    repoUrl: explicitRepoUrl ?? (await getOriginRepoUrl()),
     shouldVerifyRepoUrl: explicitRepoUrl === undefined,
 });
 
@@ -207,7 +236,7 @@ const ZERO_SHA_REGEX = /^0{40}$/;
  * Unlike the PR path (getCommits), there is no lenient fallback. Falling back to "everything"
  * would rebuild the latest build of every Actor and post it to Slack, so every problem is an error.
  */
-export const resolveReleaseBaseCommit = (baseCommit: string): string => {
+export const resolveReleaseBaseCommit = async (baseCommit: string): Promise<string> => {
     const sha = parseBaseCommit(baseCommit);
     if (!sha) {
         throw new Error('--base-commit is required for release. See the README section "Releasing Actors".');
@@ -218,15 +247,27 @@ export const resolveReleaseBaseCommit = (baseCommit: string): string => {
                 `Rerun with --base-commit set to the last commit before the changes you want to release.`,
         );
     }
-    // --quiet makes rev-parse print nothing (instead of an error) when the commit is missing
-    if (!spawnCommand(`git rev-parse --verify --quiet "${sha}^{commit}"`)) {
+    // --quiet suppresses Git's error text for a missing commit, but Git still exits with code 1.
+    const verifiedSha = await runGitCommand(['rev-parse', '--verify', '--quiet', `${sha}^{commit}`], {
+        operation: 'verify the release base commit in local Git history',
+    }).catch((error: unknown) => {
+        if (error instanceof GitCommandError && error.exitCode === 1) return '';
+        throw error;
+    });
+    if (!verifiedSha) {
         throw new Error(
             `Base commit ${sha} is not in the local git history. Either the checkout is shallow ` +
                 `(fetch the full history, e.g. fetch-depth: 0 in actions/checkout) or the branch was force-pushed.`,
         );
     }
     // git merge-base A B outputs the common ancestor. If that equals A, then A is an ancestor of B.
-    if (spawnCommand(`git merge-base ${sha} HEAD`) !== sha) {
+    const mergeBase = await runGitCommand(['merge-base', verifiedSha, 'HEAD'], {
+        operation: 'check whether the release base commit is an ancestor of HEAD',
+    }).catch((error: unknown) => {
+        if (error instanceof GitCommandError && error.exitCode === 1) return '';
+        throw error;
+    });
+    if (mergeBase !== sha) {
         throw new Error(
             `Base commit ${sha} is not an ancestor of HEAD, most likely because the branch was force-pushed. ` +
                 `The changed files cannot be determined reliably. Rerun with --base-commit set to an ancestor of HEAD ` +
@@ -239,11 +280,13 @@ export const resolveReleaseBaseCommit = (baseCommit: string): string => {
 const CHANGELOG_PATH = 'CHANGELOG.md';
 
 /** Returns the lines added to the root CHANGELOG.md between baseSha and HEAD, or null if it didn't change. */
-const getChangelogAdditions = (baseSha: string, changedFiles: string[]): string | null => {
+const getChangelogAdditions = async (baseSha: string, changedFiles: string[]): Promise<string | null> => {
     if (!changedFiles.includes(CHANGELOG_PATH)) {
         return null;
     }
-    const diff = spawnCommand('git', ['diff', baseSha, 'HEAD', '--', CHANGELOG_PATH]);
+    const diff = await runGitCommand(['diff', baseSha, 'HEAD', '--', CHANGELOG_PATH], {
+        operation: 'read changelog changes since the last release',
+    });
 
     const added: string[] = [];
     let startedChangelog = false;
@@ -271,12 +314,16 @@ const getChangelogAdditions = (baseSha: string, changedFiles: string[]): string
  * list: with a merge commit, the oldest commit of the merged branch can be older than baseSha, and
  * diffing from its parent would pull in already-released changes.
  */
-export const getReleaseChanges = (baseSha: string) => {
-    if (spawnCommand('git rev-parse HEAD') === baseSha) {
+export const getReleaseChanges = async (baseSha: string) => {
+    if (
+        (await runGitCommand(['rev-parse', 'HEAD'], { operation: 'identify the current release commit' })) === baseSha
+    ) {
         return null;
     }
-    const commits = fetchAllBranchCommits('HEAD', baseSha);
-    const changedFiles = spawnCommand(`git diff --name-only ${baseSha} HEAD`).split('\n').filter(Boolean);
-    const changelog = getChangelogAdditions(baseSha, changedFiles);
+    const commits = await fetchAllBranchCommits('HEAD', baseSha);
+    const changedFiles = await runGitCommand(['diff', '--name-only', baseSha, 'HEAD'], {
+        operation: 'list files changed since the last release',
+    }).then((output) => output.split('\n').filter(Boolean));
+    const changelog = await getChangelogAdditions(baseSha, changedFiles);
     return { commits, changedFiles, changelog };
 };

package/bin/logger.ts

@@ -0,0 +1,23 @@
+import process from 'node:process';
+import { formatWithOptions } from 'node:util';
+
+export const logLevels = ['debug', 'info', 'warn', 'error', 'silent'] as const;
+export type LogLevel = (typeof logLevels)[number];
+
+let currentLevel: LogLevel = 'info';
+
+const write = (level: Exclude<LogLevel, 'silent'>, args: unknown[]) => {
+    if (logLevels.indexOf(level) < logLevels.indexOf(currentLevel)) return;
+    process.stderr.write(`${formatWithOptions({ colors: false }, ...args)}\n`);
+};
+
+/** All diagnostics go to stderr, leaving stdout available for machine-readable results. */
+export const logger = {
+    setLevel(level: LogLevel): void {
+        currentLevel = level;
+    },
+    debug: (...args: unknown[]): void => write('debug', args),
+    info: (...args: unknown[]): void => write('info', args),
+    warn: (...args: unknown[]): void => write('warn', args),
+    error: (...args: unknown[]): void => write('error', args),
+};

package/bin/main.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env -S node --no-warnings
 
 import process from 'node:process';
 
@@ -20,11 +20,18 @@ import {
     resolveReleaseBaseCommit,
     resolveRepoUrl,
 } from './git.js';
+import { logger, logLevels } from './logger.js';
+import { writeJson } from './output.js';
 import { notifyToSlack } from './slack.js';
 import { reportTestResults } from './test-report.js';
 import type { Config } from './types.js';
 import { readConfigFile } from './utils/config/load-config.js';
 
+/**
+ * Middlewares to be run before every command execution
+ */
+const middlewares = [(args: { logLevel: (typeof logLevels)[number] }) => logger.setLevel(args.logLevel)];
+
 /*
  * Option groups shared across commands. Each is a plain object passed to `.options()`, so a command's
  * builder composes them by chaining (`y.options(gitRangeOptions).options(actorSelectionOptions)`)
@@ -64,6 +71,12 @@ const buildOptions = {
 
 /** Global flags, available to every command. */
 const globalOptions = {
+    'log-level': {
+        type: 'string',
+        choices: logLevels,
+        default: 'info',
+        describe: 'Minimum diagnostic level written to stderr; silent disables logging',
+    },
     'dry-run': { type: 'boolean', default: false },
 } as const satisfies Record<string, Options>;
 
@@ -75,53 +88,54 @@ const resolveChangedActors = async (config: Config, { isLatest }: { isLatest: bo
     // since the branch has no functional changes of its own, there is nothing new to validate.
     // Exception: if the branch has any functional changes alongside the merge, we must re-test — even
     // individually validated changes can have novel interactions when combined.
-    if (hasMergeFromTarget(config.sourceBranch, config.targetBranch)) {
-        console.error(
+    if (await hasMergeFromTarget(config.sourceBranch, config.targetBranch)) {
+        logger.info(
             '[MERGE-FROM-TARGET-OPTIMIZATION]: There is merge from target branch, checking if there are no functional changes in our own branch. If so, we can skip tests',
         );
-        const branchOnlyFiles = getBranchOnlyChangedFiles(config.sourceBranch, config.targetBranch);
+        const branchOnlyFiles = await getBranchOnlyChangedFiles(config.sourceBranch, config.targetBranch);
         // Omit baseCommit to get full branch history. Validated functional commits can still interact with merged ones
-        const allBranchCommits = getCommits({ ...config, baseCommit: undefined });
-        const branchOnlyActorsChanged = getChangedActors({
+        const allBranchCommits = await getCommits({ ...config, baseCommit: undefined });
+        const branchOnlyActorsChanged = await getChangedActors({
             filepathsChanged: branchOnlyFiles,
             actorConfigs,
             commits: allBranchCommits,
         });
         if (branchOnlyActorsChanged.length === 0) {
-            console.error('[MERGE-FROM-TARGET-OPTIMIZATION]: Branch itself has no functional changes, skipping tests');
+            logger.info('[MERGE-FROM-TARGET-OPTIMIZATION]: Branch itself has no functional changes, skipping tests');
             return [];
         }
-        console.error(
+        logger.info(
             `[MERGE-FROM-TARGET-OPTIMIZATION]: Branch has ${branchOnlyActorsChanged.length} functional changes, cannot optimize, we continue with full check`,
         );
     }
 
     // If the optimization doesn't apply, we check all branch commits including merges for full coverage. We don't reuse the merge optimization results because here we can apply baseCommit and check merge commits (they might be functional or just cosmetic)
-    const commits = getCommits(config);
-    const changedFiles = getChangedFiles(commits);
+    const commits = await getCommits(config);
+    const changedFiles = await getChangedFiles(commits);
     return getChangedActors({ filepathsChanged: changedFiles, actorConfigs, isLatest, commits });
 };
 
 await yargs()
     .scriptName('public-actors-utils')
     .options(globalOptions)
+    .middleware(middlewares)
     .command(
         'get-commits',
         '',
         (y) => y.options(gitRangeOptions),
-        (args) => {
-            const commits = getCommits(args);
-            console.log(JSON.stringify(commits));
+        async (args) => {
+            const commits = await getCommits(args);
+            writeJson(commits);
         },
     )
     .command(
         'get-latest-commit',
         '',
         (y) => y.options(gitRangeOptions),
-        (args) => {
-            const commits = getCommits(args);
+        async (args) => {
+            const commits = await getCommits(args);
             if (commits.length > 0) {
-                console.log(JSON.stringify(commits[commits.length - 1]));
+                writeJson(commits[commits.length - 1]);
             }
         },
     )
@@ -129,10 +143,10 @@ await yargs()
         'get-changed-files',
         '',
         (y) => y.options(gitRangeOptions),
-        (args) => {
-            const commits = getCommits(args);
-            const changedFiles = getChangedFiles(commits);
-            console.log(JSON.stringify(changedFiles));
+        async (args) => {
+            const commits = await getCommits(args);
+            const changedFiles = await getChangedFiles(commits);
+            writeJson(changedFiles);
         },
     )
     .command(
@@ -141,7 +155,7 @@ await yargs()
         (y) => y.options(actorSelectionOptions),
         async ({ actors, ignore }) => {
             const actorConfigs = await readConfigFile({ actors, ignore });
-            console.log(JSON.stringify(actorConfigs));
+            writeJson(actorConfigs);
         },
     )
     .command(
@@ -150,7 +164,7 @@ await yargs()
         (y) => y.options(gitRangeOptions).options(actorSelectionOptions),
         async (config) => {
             const actorsChanged = await resolveChangedActors(config, { isLatest: false });
-            console.log(JSON.stringify(actorsChanged));
+            writeJson(actorsChanged);
         },
     )
     .command(
@@ -173,13 +187,13 @@ await yargs()
         async (config) => {
             const actorsChanged = await resolveChangedActors(config, { isLatest: false });
             const builds = await runBuilds({
-                ...resolveRepoUrl(config.repoUrl),
+                ...(await resolveRepoUrl(config.repoUrl)),
                 actorConfigs: actorsChanged,
                 branch: config.sourceBranch.replace('origin/', ''),
                 dryRun: config.dryRun,
                 useDockerCache: config.useDockerCache,
             });
-            console.log(JSON.stringify(builds));
+            writeJson(builds);
         },
     )
     .command(
@@ -196,19 +210,19 @@ await yargs()
                 .option('report-slack-channel', { type: 'string' })
                 .option('release-slack-channel', { type: 'string' }),
         async (args) => {
-            const baseSha = resolveReleaseBaseCommit(args.baseCommit);
-            const branch = getCurrentBranch();
-            const changes = getReleaseChanges(baseSha);
+            const baseSha = await resolveReleaseBaseCommit(args.baseCommit);
+            const branch = await getCurrentBranch();
+            const changes = await getReleaseChanges(baseSha);
             if (!changes) {
-                console.error(`HEAD is the base commit ${baseSha}, there is nothing new to release`);
+                logger.info(`HEAD is the base commit ${baseSha}, there is nothing new to release`);
                 return;
             }
             const { commits, changedFiles, changelog } = changes;
-            const { repoUrl, shouldVerifyRepoUrl } = resolveRepoUrl(args.repoUrl);
+            const { repoUrl, shouldVerifyRepoUrl } = await resolveRepoUrl(args.repoUrl);
 
             const isLatest = true;
             const actorConfigs = await readConfigFile(args);
-            const actorsChanged = getChangedActors({
+            const actorsChanged = await getChangedActors({
                 filepathsChanged: changedFiles,
                 actorConfigs,
                 isLatest,
@@ -224,7 +238,7 @@ await yargs()
                 dryRun,
                 useDockerCache: args.useDockerCache,
             });
-            console.error(JSON.stringify(builds));
+            logger.info(JSON.stringify(builds));
 
             await notifyToSlack({
                 changedFiles,
@@ -246,7 +260,7 @@ await yargs()
         async ({ actors, ignore, dryRun }) => {
             const actorConfigs = await readConfigFile({ actors, ignore });
             const builds = await runBuildsFromLocal({ actorConfigs, dryRun });
-            console.log(JSON.stringify(builds));
+            writeJson(builds);
         },
     )
     .command(
@@ -265,11 +279,11 @@ await yargs()
         // or a missing config file) arrive here as `err`. A malformed selection must fail loudly
         // rather than silently operate on the wrong set of actors — print the message, no stack.
         if (err) {
-            console.error(`[ERROR]: ${err.message}`);
+            logger.error(`[ERROR]: ${err.message}`);
         } else {
             // Argument-parsing/validation failure — keep yargs' usage output.
-            console.error(yargsInstance.help());
-            console.error(`\n${msg}`);
+            logger.error(yargsInstance.help());
+            logger.error(`\n${msg}`);
         }
         process.exit(1);
     })

package/bin/output.ts

@@ -0,0 +1,6 @@
+import process from 'node:process';
+
+/** CLI results always go to stdout, independently of the diagnostic log level. */
+export const writeJson = (value: unknown): void => {
+    process.stdout.write(`${JSON.stringify(value)}\n`);
+};

package/bin/slack.ts

@@ -1,5 +1,6 @@
 import { WebClient } from '@slack/web-api';
 
+import { logger } from './logger.js';
 import type { Commit } from './types.js';
 import { getEnvVar } from './utils.js';
 
@@ -30,7 +31,7 @@ export const notifyToSlack = async ({
     const slack = new WebClient(getEnvVar('SLACK_TOKEN_RELEASES_BOT'));
 
     if (!changelog) {
-        console.warn('No new changelog entries found, did you forget to update it?');
+        logger.warn('No new changelog entries found, did you forget to update it?');
     }
 
     let shortMessage = `*${repository}* – New release (by ${displayName(author)}):\n\n`;
@@ -38,9 +39,9 @@ export const notifyToSlack = async ({
     // This one is just for broader public that only cares about public facing changes
     if (changelog && releaseSlackChannel) {
         shortMessage += `*Additions to the changelog*:\n\n${changelog}\n`;
-        console.error(`=========================================`);
-        console.error(`**Sending slack message to channel**: ${releaseSlackChannel}.\n\n${shortMessage}`);
-        console.error(`=========================================`);
+        logger.info(`=========================================`);
+        logger.info(`**Sending slack message to channel**: ${releaseSlackChannel}.\n\n${shortMessage}`);
+        logger.info(`=========================================`);
         if (!dryRun) {
             await slack.chat.postMessage({
                 channel: releaseSlackChannel,
@@ -60,9 +61,9 @@ export const notifyToSlack = async ({
 
     // This one is for devs and project managers that need to know more details
     if (reportSlackChannel) {
-        console.error(`=========================================`);
-        console.error(`Sending slack message to channel: ${reportSlackChannel}.\n\n${longMessage}`);
-        console.error(`=========================================`);
+        logger.info(`=========================================`);
+        logger.info(`Sending slack message to channel: ${reportSlackChannel}.\n\n${longMessage}`);
+        logger.info(`=========================================`);
         if (!dryRun) {
             await slack.chat.postMessage({
                 text: longMessage,

package/bin/test-report.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs/promises';
 
+import { logger } from './logger.js';
 import { sendSlackMessage } from './slack.js';
 import { getEnvVar } from './utils.js';
 
@@ -38,23 +39,23 @@ export const reportTestResults = async ({
 
     const failedAssertions: { message: string; runLink: string; actorId: string }[] = [];
 
-    console.error();
-    console.error(`PASSED: ${passed.length}, FAILED: ${failed.length}`);
-    console.error();
-    console.error('**************************************************');
-    console.error('*                   Successes                    *');
-    console.error('**************************************************');
-    console.error();
+    logger.info();
+    logger.info(`PASSED: ${passed.length}, FAILED: ${failed.length}`);
+    logger.info();
+    logger.info('**************************************************');
+    logger.info('*                   Successes                    *');
+    logger.info('**************************************************');
+    logger.info();
     for (const [i, aResult] of passed.entries()) {
         const { fullName } = aResult;
-        console.error(`${i + 1}) ${fullName} ... ${aResult.meta.runLink}`);
-        console.error();
+        logger.info(`${i + 1}) ${fullName} ... ${aResult.meta.runLink}`);
+        logger.info();
     }
 
-    console.error('**************************************************');
-    console.error('*                   Failures                     *');
-    console.error('**************************************************');
-    console.error();
+    logger.info('**************************************************');
+    logger.info('*                   Failures                     *');
+    logger.info('**************************************************');
+    logger.info();
     for (const [i, aResult] of failed.entries()) {
         const { failureMessages, fullName, meta } = aResult;
         if (failureMessages) {
@@ -66,15 +67,15 @@ export const reportTestResults = async ({
                 })),
             );
         }
-        console.error(`${i + 1}) ${fullName} ... ${meta.runLink}`);
-        console.error();
+        logger.info(`${i + 1}) ${fullName} ... ${meta.runLink}`);
+        logger.info();
     }
-    console.error();
-    console.error(`PASSED: ${passed.length}, FAILED: ${failed.length}`);
-    console.error();
+    logger.info();
+    logger.info(`PASSED: ${passed.length}, FAILED: ${failed.length}`);
+    logger.info();
 
     if (!reportSlackChannel) {
-        console.error(
+        logger.info(
             `Skipping slack notification. If you want to enable it, add --report-slack-channel flag and make sure SLACK_TOKEN_TESTS_BOT env variable is set.`,
         );
         return;
@@ -94,8 +95,8 @@ export const reportTestResults = async ({
         .slice(1)
         .map(({ message, runLink, actorId }) => `• ${message} --- <${runLink}|${actorId}>`);
 
-    console.error('SLACK:', slackMessage);
-    console.error('\tblocks:', blocks.join('\n\t\t'));
+    logger.info('SLACK:', slackMessage);
+    logger.info('\tblocks:', blocks.join('\n\t\t'));
 
     if (!reportSlackChannel) {
         return;