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

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;

package/bin/utils/config/actor-json.ts

@@ -0,0 +1,84 @@
+import z from 'zod';
+
+import { safeReadJsonObjectFile } from '../json-file.js';
+import { ExistingFile, type RelativeDir, type RelativeFile } from '../path/repo-relative.js';
+import type { ValidatedActorConfig } from './structures/base.js';
+
+const inlineOrPath = z.union([z.string(), z.record(z.string(), z.unknown())]).nullish();
+
+const ActorJsonFieldsSchema = z.object({
+    dockerContextDir: z.string().default('..'),
+    dockerfile: z.string().optional(),
+    readme: z.string().nullish(),
+    changelog: z.string().nullish(),
+    input: inlineOrPath,
+    inputSchema: inlineOrPath,
+    output: inlineOrPath,
+    outputSchema: inlineOrPath,
+    webServerSchema: inlineOrPath,
+});
+
+export interface ActorJsonPaths {
+    file: ExistingFile;
+    dockerContextDir: RelativeDir;
+    dockerfile?: RelativeFile;
+    readme?: RelativeFile;
+    changelog?: RelativeFile;
+    inputSchema?: RelativeFile;
+    outputSchema?: RelativeFile;
+    webServerSchema?: RelativeFile;
+}
+
+const resolveFile = (actorJsonFile: ExistingFile, field: string, value: unknown): RelativeFile | undefined => {
+    if (typeof value !== 'string') return undefined;
+    try {
+        return actorJsonFile.joinFile(value);
+    } catch (error) {
+        throw new Error(`Invalid "${field}" in "${actorJsonFile}": ${(error as Error).message}`);
+    }
+};
+
+export function readActorJson(config: ValidatedActorConfig): ActorJsonPaths {
+    const actorJsonPath = config.folder.joinFile('.actor/actor.json');
+    let actorJsonFile: ExistingFile;
+    try {
+        actorJsonFile = ExistingFile.initialize(actorJsonPath);
+    } catch {
+        throw new Error(
+            `Cannot read "${actorJsonPath}". Every actor entry must have a corresponding .actor/actor.json file.`,
+        );
+    }
+
+    const json = safeReadJsonObjectFile(actorJsonFile);
+    if (!json.success) throw new Error(`Cannot read "${actorJsonFile}". ${json.failure.message}`);
+
+    const parsed = ActorJsonFieldsSchema.safeParse(json.contents);
+    if (!parsed.success) throw new Error(`Invalid "${actorJsonFile}": ${z.prettifyError(parsed.error)}`);
+
+    const fields = parsed.data;
+    let dockerContextDir: RelativeDir;
+    try {
+        dockerContextDir = actorJsonFile.joinDir(fields.dockerContextDir);
+    } catch (error) {
+        throw new Error(`Invalid "dockerContextDir" in "${actorJsonFile}": ${(error as Error).message}`);
+    }
+
+    return {
+        file: actorJsonFile,
+        dockerContextDir,
+        dockerfile: resolveFile(actorJsonFile, 'dockerfile', fields.dockerfile),
+        readme: resolveFile(actorJsonFile, 'readme', fields.readme),
+        changelog: resolveFile(actorJsonFile, 'changelog', fields.changelog),
+        inputSchema: resolveFile(
+            actorJsonFile,
+            fields.input != null ? 'input' : 'inputSchema',
+            fields.input ?? fields.inputSchema,
+        ),
+        outputSchema: resolveFile(
+            actorJsonFile,
+            fields.output != null ? 'output' : 'outputSchema',
+            fields.output ?? fields.outputSchema,
+        ),
+        webServerSchema: resolveFile(actorJsonFile, 'webServerSchema', fields.webServerSchema),
+    };
+}

package/bin/utils/config/load-config.ts

@@ -1,30 +1,26 @@
-import path from 'node:path';
-
 import { selectActors } from '../../actor-filtering.js';
-import { isPathWithinScope } from '../../path-utils.js';
 import type { ActorConfig } from '../../types.js';
 import { safeReadJsonObjectFile } from '../json-file.js';
+import { type ExistingDir, ExistingFile, type RelativeDir } from '../path/repo-relative.js';
+import { type ActorJsonPaths, readActorJson } from './actor-json.js';
 import { parseConfigFile } from './parser.js';
-import type { ResolvedActorConfig } from './structures/base.js';
+import type { ValidatedActorConfig } from './structures/base.js';
 
 export const CONFIG_FILE_NAME = 'apify-test-tools.config.json';
 
 // Reading the config happens in three stages, each one swappable on its own:
 //
 //   1. file                -> plain object          (safeReadJsonObjectFile)
-//   2. plain object        -> ResolvedActorConfig[] (parseConfigFile — picks a strategy, validates
+//   2. plain object        -> ValidatedActorConfig[] (parseConfigFile — picks a strategy, validates
 //                                                    and normalizes; see ./parser.ts)
-//   3. ResolvedActorConfig -> ActorConfig           (loadActorConfig — merges in .actor/actor.json)
+//   3. ValidatedActorConfig -> LoadedActorConfig    (loadActorConfig — reads .actor/actor.json)
 
 // #region utils
 
-const findOverlappingContextPaths = (contextPaths: string[]): [string, string] | undefined => {
+const findOverlappingContextPaths = (contextPaths: RelativeDir[]): [RelativeDir, RelativeDir] | undefined => {
     for (let i = 0; i < contextPaths.length; i++) {
         for (let j = i + 1; j < contextPaths.length; j++) {
-            if (
-                isPathWithinScope(contextPaths[i], contextPaths[j]) ||
-                isPathWithinScope(contextPaths[j], contextPaths[i])
-            ) {
+            if (contextPaths[i].contains(contextPaths[j]) || contextPaths[j].contains(contextPaths[i])) {
                 return [contextPaths[i], contextPaths[j]];
             }
         }
@@ -32,9 +28,17 @@ const findOverlappingContextPaths = (contextPaths: string[]): [string, string] |
     return undefined;
 };
 
-// The repo root is spelled "" internally but "." in a config file, so report it the way a reader
-// would have written it.
-const displayFolder = (folder: string): string => folder || '.';
+// Downstream ActorConfig consumers still use "" for the repo root.
+const legacyPath = (dir: RelativeDir): string => (dir.path === '.' ? '' : dir.path);
+
+export interface LoadedActorConfig {
+    actorFullName: string;
+    folder: ExistingDir;
+    tokenEnvVar: string;
+    actorJson: ActorJsonPaths;
+    dockerContextDir: RelativeDir;
+    contextPaths: RelativeDir[];
+}
 
 // #endregion
 
@@ -42,7 +46,16 @@ const displayFolder = (folder: string): string => folder || '.';
 
 /** Stage 1 — the config file as a plain object, or a failure phrased for whoever wrote it. */
 const readConfigFileContents = async (): Promise<Record<string, unknown>> => {
-    const file = safeReadJsonObjectFile(CONFIG_FILE_NAME);
+    let configFile: ExistingFile;
+    try {
+        configFile = new ExistingFile(CONFIG_FILE_NAME);
+    } catch {
+        throw new Error(
+            `Config file "${CONFIG_FILE_NAME}" not found in the current directory. ` +
+                `Please create one with the required actor entries.`,
+        );
+    }
+    const file = safeReadJsonObjectFile(configFile);
     if (file.success) {
         return file.contents;
     }
@@ -66,57 +79,44 @@ const readConfigFileContents = async (): Promise<Record<string, unknown>> => {
  * Stage 3 — resolves one normalized entry against the repo, reading the actor's `.actor/actor.json`
  * for its `dockerContextDir` and deciding which paths count as the actor's context.
  */
-export const loadActorConfig = (entry: ResolvedActorConfig): ActorConfig => {
+export const loadActorConfig = (entry: ValidatedActorConfig): LoadedActorConfig => {
     const { folder } = entry;
-    const actorJsonPath = folder ? `${folder}/.actor/actor.json` : '.actor/actor.json';
-
-    const actorJson = safeReadJsonObjectFile(actorJsonPath);
-    if (!actorJson.success) {
-        throw new Error(
-            `Cannot read "${actorJsonPath}". Every actor entry in "${CONFIG_FILE_NAME}" ` +
-                `must have a corresponding .actor/actor.json file.`,
-        );
-    }
-
-    const actorDotDir = folder ? `${folder}/.actor` : '.actor';
-    const rawDockerContextDir =
-        typeof actorJson.contents.dockerContextDir === 'string' ? actorJson.contents.dockerContextDir : '..';
-    const resolved = path.resolve(process.cwd(), actorDotDir, rawDockerContextDir);
-    const dockerContextDir = path.relative(process.cwd(), resolved);
-
-    if (dockerContextDir.startsWith('..')) {
-        throw new Error(
-            `"dockerContextDir" for folder "${displayFolder(folder)}" resolves outside the repository root. ` +
-                `Resolved path: "${dockerContextDir}".`,
-        );
-    }
-
-    const normalizedDockerContextDir = dockerContextDir === '.' ? '' : dockerContextDir;
-    const contextPaths = [...(entry.overrideActorContext ?? [normalizedDockerContextDir])];
+    const actorJson = readActorJson(entry);
+    const { dockerContextDir } = actorJson;
+    const contextPaths = [...(entry.overrideActorContext ?? [dockerContextDir])];
 
     // The actor's own folder is always part of its context. When an explicit "overrideActorContext"
     // doesn't already cover it, add it automatically instead of failing the workflow.
-    if (!contextPaths.some((contextPath) => isPathWithinScope(folder, contextPath))) {
+    if (!contextPaths.some((contextPath) => contextPath.contains(folder))) {
         contextPaths.push(folder);
     }
 
     const overlap = findOverlappingContextPaths(contextPaths);
     if (overlap) {
         throw new Error(
-            `Invalid context paths for folder "${displayFolder(folder)}" in "${CONFIG_FILE_NAME}": ` +
+            `Invalid context paths for folder "${folder}" in "${CONFIG_FILE_NAME}": ` +
                 `"${overlap[0]}" and "${overlap[1]}" overlap. Context paths must not be prefixes of one another.`,
         );
     }
 
     return {
         actorFullName: entry.actorFullName,
-        folder,
+        folder: entry.folder,
         tokenEnvVar: entry.tokenEnvVar,
-        dockerContextDir: normalizedDockerContextDir,
+        actorJson,
+        dockerContextDir,
         contextPaths,
     };
 };
 
+const toLegacyActorConfig = (entry: LoadedActorConfig): ActorConfig => ({
+    actorFullName: entry.actorFullName,
+    folder: legacyPath(entry.folder),
+    tokenEnvVar: entry.tokenEnvVar,
+    dockerContextDir: legacyPath(entry.dockerContextDir),
+    contextPaths: entry.contextPaths.map(legacyPath),
+});
+
 // #endregion
 
 export const readConfigFile = async (selection: { actors: string[]; ignore: string[] }): Promise<ActorConfig[]> => {
@@ -126,7 +126,7 @@ export const readConfigFile = async (selection: { actors: string[]; ignore: stri
     const actorConfigs: ActorConfig[] = [];
     for (const parsed of parsedConfigs) {
         // Sequential on purpose: the first actor with a problem should be the one reported.
-        actorConfigs.push(loadActorConfig(parsed));
+        actorConfigs.push(toLegacyActorConfig(loadActorConfig(parsed)));
     }
 
     return selectActors(selection, actorConfigs);