apify-test-tools 0.9.1-beta.1 → 0.9.1-beta.10

package/README.md

@@ -99,7 +99,12 @@ See the [GitHub workflows](#github-worklows) section below.
 
 ## Github worklows
 
-There should be 4 GH workflow files in `.github/workflows`.
+The reusable workflows live in this repo, alongside the package they call. They are the
+`public_`-prefixed files in `.github/workflows`; everything else there is this repo's own CI.
+Reference them at the `@workflows-v0` major tag, never at `@master` — see
+[Versioning and releases](#versioning-and-releases).
+
+There should be 4 GH workflow files in `.github/workflows`, plus an optional fifth for Claude reviews.
 
 ### `platform-tests-core.yaml`
 
@@ -114,7 +119,7 @@ on:
 
 jobs:
     platformTestsCore:
-        uses: apify-store/github-actions-source/.github/workflows/platform-tests.yaml@new_master
+        uses: apify/apify-test-tools/.github/workflows/public_platform-tests.yaml@workflows-v0
         with:
             subtest: core
         secrets: inherit
@@ -133,7 +138,7 @@ on:
 
 jobs:
     platformTestsDaily:
-        uses: apify-store/github-actions-source/.github/workflows/platform-tests.yaml@new_master
+        uses: apify/apify-test-tools/.github/workflows/public_platform-tests.yaml@workflows-v0
         secrets: inherit
 ```
 
@@ -148,7 +153,7 @@ on:
 
 jobs:
     buildDevelAndTest:
-        uses: apify-store/github-actions-source/.github/workflows/pr-build-test.yaml@new_master
+        uses: apify/apify-test-tools/.github/workflows/public_pr-build-test.yaml@workflows-v0
         secrets: inherit
 ```
 
@@ -163,10 +168,149 @@ on:
 
 jobs:
     buildLatest:
-        uses: apify-store/github-actions-source/.github/workflows/push-build-latest.yaml@new_master
+        uses: apify/apify-test-tools/.github/workflows/public_push-build-latest.yaml@workflows-v0
         secrets: inherit
 ```
 
+### `claude-review.yaml`
+
+Optional. Reviews a PR against the shared guidelines when you add the trigger label, and again on
+every push while that label is on.
+
+```yaml
+name: Claude review
+
+on:
+    pull_request:
+        types: [labeled, synchronize]
+
+jobs:
+    review:
+        uses: apify/apify-test-tools/.github/workflows/public_review.yaml@workflows-v0
+        secrets: inherit
+```
+
+The review instructions live in `.github/review-prompt.md` in this repo and are fetched at run time,
+because a reusable workflow doesn't get its own repo checked out. `prompt-ref` selects which ref to
+fetch them from and defaults to `workflows-v0`, so the instructions match the workflow you're calling — point
+it at a branch only to test a prompt change.
+
+### Secrets
+
+Callers pass `secrets: inherit`. The workflows do not turn every inherited secret into job-wide
+environment variables, so a secret is only visible to the step that needs it:
+
+| Secret                                                                    | Reaches                                                                                                                                                                                                                |
+| ------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `NPM_TOKEN`                                                               | dependency install steps only, as both `NPM_TOKEN` and `NODE_AUTH_TOKEN`. Use a read-only token: npm granular tokens can be read-only, classic automation tokens can publish.                                          |
+| the Actor tokens named by `tokenEnvVar` in `apify-test-tools.config.json` | the `build`, `release`, and `delete-old-builds` steps only                                                                                                                                                             |
+| `TESTER_APIFY_TOKEN`                                                      | the vitest step only                                                                                                                                                                                                   |
+| `SLACK_TOKEN_TESTS_BOT` / `SLACK_TOKEN_RELEASES_BOT`                      | the reporting and release steps only                                                                                                                                                                                   |
+| `TESTER_APIFY_TOKEN_READ_ONLY`                                            | the Claude investigation step only, as the Apify MCP server's bearer token. Required by `public_platform-tests-claude-investigate-and-fix`. Use a read-only token: it reads the failing run, its log and its storages. |
+
+The Actor tokens are the one set that cannot be listed in the workflow, because each Actor names its
+own token via `tokenEnvVar` in `apify-test-tools.config.json`. Those steps pass
+`${{ toJSON(secrets) }}` as `ALL_SECRETS` and run the command through
+`.github/scripts/run-with-apify-tokens.mjs`, which reads that same config file to decide which
+secrets to pass on:
+
+```yaml
+- name: Build
+  env:
+      ALL_SECRETS: ${{ toJSON(secrets) }}
+  run: |
+      node "${{ steps.setup.outputs.scripts-path }}/run-with-apify-tokens.mjs" \
+        npx apify-test-tools build --target-branch ...
+```
+
+The wrapper passes only the tokens the config declares and drops `ALL_SECRETS`, so neither `npx` nor
+anything under `node_modules` sees the blob. Nothing is written to `$GITHUB_ENV`, so the tokens stay
+inside that one command rather than leaking into later steps. Reading the same file
+`apify-test-tools` reads means the two can't drift, and a secret that merely looks like an Actor
+token is not passed just because of its name.
+
+A token the config declares but the repo hasn't set is a warning, not a failure: a repo can carry an
+Actor whose token isn't configured and still build fine as long as that Actor never changes, and
+`apify-test-tools` raises a precise error naming the Actor at the point it actually needs the token.
+
+`scripts-path` comes from the setup action (give the step `id: setup`) and points at this repo's
+`.github/scripts/` directory inside the runner's action checkout, so workflows can run these helpers
+without checking this repo out again. The caller's workspace holds the caller's repo, not this one.
+
+Two tidier-looking alternatives don't work, so don't reach for them:
+
+- **Exporting to `$GITHUB_ENV`** would let the steps call `npx` directly with no wrapper, but
+  `$GITHUB_ENV` applies to every later step in the job. In `pr-build-test` the vitest step runs after
+  the build, so it would inherit Actor tokens it has no use for.
+- **Returning the tokens as a step output** would be scoped correctly, but the runner refuses to set
+  an output whose value contains a registered secret. It logs `Skip output <name> since it may
+contain secret` and leaves the output empty, so anything reading it downstream gets nothing.
+
+The `unitTest` job runs static checks and needs `NPM_TOKEN` only. No job runs `npm ci` with Apify or
+Slack credentials in scope, so a postinstall script in the dependency tree cannot read them.
+
+## Versioning and releases
+
+The workflows and the npm package live in one repo but ship on their own schedules. Two pointers
+decide what a consumer repo actually runs:
+
+| Pointer                             | What it selects                                | Moves when                                               |
+| ----------------------------------- | ---------------------------------------------- | -------------------------------------------------------- |
+| the `@workflows-v0` tag in `uses:`  | which workflows run                            | a master push, once the version below is published       |
+| `.github/workflows-package-version` | which `apify-test-tools` the workflows install | a stable release writes it; you may set it ahead of time |
+
+The setup action installs that **exact** version — not a range. A tag is therefore a complete
+statement: these workflows _and_ this library. The stable release writes the file into the same
+commit that bumps `package.json` and `CHANGELOG.md`, so a released commit always names the version
+it published, and rollout latency is unchanged: the release publishes and moves the tag in one run.
+
+Prereleases are excluded. Master pushes publish a `-beta` that consumer repos must never install, so
+the pin only moves on a stable release; betas stay reachable through the lockfile path in the setup
+action, which is how branch testing works.
+
+Nothing is coupled that doesn't need to be:
+
+- **Workflow-only change** — merge it. `workflows-v0` moves, it goes live, no release needed.
+- **Package-only change** — merge it, then cut a release when you want it out. The workflows are
+  unchanged, so consumers see nothing until the release lands.
+- **A workflow that calls a new CLI feature** — the one case that can break consumers, and the only
+  one with any ceremony. Put the package change, the workflow change, and the new pin in one PR. On
+  merge the tag is **held**: the CI job reports that the pinned version isn't on npm and leaves `workflows-v0`
+  where it is, so consumers keep running the previous workflows. Cut a stable release, and the tag
+  moves on its own. Run **Move major version tag** if you don't want to wait for the next master
+  push.
+
+`workflows-v0` moving on every master push means `@workflows-v0` is as live as `@master` was —
+there's no staging step, just a gate on the package version. What the tag buys you is a
+`workflows-v1` for breaking workflow changes, so repos migrate one at a time instead of all at once,
+and a way to roll back by pointing the tag at an earlier commit. Bump `MAJOR_TAG` in
+`.github/workflows/_move_major_tag.yaml` to cut the next major; the old tag then freezes where it is
+and keeps working.
+
+Freezing is real, which is the whole reason the version is pinned rather than a floor. A frozen `workflows-v0`
+points at a commit whose pinned version never changes, so it keeps installing the library it was
+tested against no matter how far the package moves on. Had the workflows installed `>=<floor>`, a
+frozen `workflows-v0` would still resolve to whatever is newest — and since the release that enables
+`workflows-v1` is usually the same release that breaks `workflows-v0`, the migration window would
+have been zero.
+
+The tag tracks the **workflows'** contract, not the npm package version. They move independently on
+purpose, so `@workflows-v0` is expected to stay `@workflows-v0` after the package reaches 1.0 —
+bump it when a workflow breaks its callers, not when the package does. Because `uses:` cannot take an expression, every ref
+into this repo repeats the tag literally; `check-major-tag-refs.mjs` fails the build if `MAJOR_TAG`
+and those refs disagree, which is the mistake that would otherwise ship silently during a bump.
+
+### Testing workflow changes
+
+- Point [testing-repo-for-github-actions](https://github.com/apify-store/testing-repo-for-github-actions)
+  at your branch (`uses: ...@your-branch`). It has real attached Actors and tests. Because the
+  package lives here too, a master push publishes a `beta`, and the lockfile-beta path in the setup
+  action installs that exact version — so one branch tests both halves of a change together.
+- To change the composite action itself, repoint the `uses:` refs inside the reusable workflows at
+  your branch as well, and change them back before merging.
+- Make sure the shell code actually works on your laptop first.
+- After merging, watch the workflow on a real project before moving on.
+
 ## Writing tests
 
 ### Test structure
@@ -418,7 +562,7 @@ Remove `--dry-run` to actually trigger builds and update the branch names/ The c
 
 #### Build from local source (no push needed)
 
-If you don't want to push a dummy branch just to test a change and wait for all the tests to finish, `build-from-local` builds Actors directly from your local files (zipped and uploaded as `SOURCE_FILES`), skipping steps 1-4 above.
+If you don't want to push a dummy branch just to test a change and wait for all the tests to finish, `build-from-local` builds Actors directly from your local files (zipped into the Actor's `actor-<id>-source` key-value store and built as `TARBALL`, like `apify push`), skipping steps 1-4 above.
 
 ```bash
 APIFY_TOKEN_JOHN_DOE=<token> \
@@ -439,14 +583,13 @@ Since you already scoped the build to just the Actor(s) you care about, point vi
 
 #### 5. Run tests against the builds
 
-Pass the build output as `ACTOR_BUILDS` and provide `TESTER_APIFY_TOKEN`. The token can point to your own account (if you have enough memory) or you can use the testing account (xRGg9iAfJSymqartk).
+Pass the build output as `ACTOR_BUILDS` and provide `TESTER_APIFY_TOKEN`. The token can point to your own account (if you have enough memory) or you can use the testing account (xRGg9iAfJSymqartk). Platform test suites are skipped unless `TESTER_APIFY_TOKEN` is set, so regular unit test runs stay unaffected.
 
 If you want to run only certain tests, change the `test/platform` to be more specific.
 
 ```bash
 ACTOR_BUILDS='<JSON output from build command>' \
 TESTER_APIFY_TOKEN=<token> \
-RUN_PLATFORM_TESTS=1 \
   npx vitest --run --maxConcurrency 20 --fileParallelism=true --maxWorkers 100 test/platform
 ```
 
@@ -463,7 +606,6 @@ BUILDS=$(APIFY_TOKEN_JOHN_DOE=apify_api_xxx \
 # Run tests with the builds
 ACTOR_BUILDS="$BUILDS" \
 TESTER_APIFY_TOKEN=apify_api_yyy \
-RUN_PLATFORM_TESTS=1 \
   npx vitest --run --maxConcurrency 20 --fileParallelism=true --maxWorkers 100 test/platform
 ```
 

package/bin/build-from-local.ts

@@ -2,13 +2,16 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
-import type { ActorVersionSourceFile } from 'apify-client';
+import AdmZip from 'adm-zip';
+import type { ActorVersion } from 'apify-client';
+import { ActorSourceType } from 'apify-client';
 
-import { ApifyBuilder, waitAndSummarizeBuilds } from './build.js';
+import { dryRunBuildData, LOCAL_SOURCE_VERSION_NUMBER, runAndSummarizeBuilds } from './build.js';
 import { buildDockerIgnoreMatcher } from './dockerignore.js';
 import { isPathWithinScope } from './path-utils.js';
 import type { ActorConfig, BuildData } from './types.js';
-import { getGitignoredPaths, isOutsideDir, listRepoFilePaths, toActorVersionSourceFile } from './utils.js';
+import type { SourceFile } from './utils.js';
+import { getGitignoredPaths, isOutsideDir, listRepoFilePaths, readSourceFile } from './utils.js';
 
 // JUST IN CASE. File patterns that commonly hold credentials — never ship these into a build, regardless
 // of sourceType or of whether the repo's .gitignore happens to list them. Everything else that should be
@@ -17,7 +20,7 @@ import { getGitignoredPaths, isOutsideDir, listRepoFilePaths, toActorVersionSour
 const SKIP_FILE_PATTERNS = [/^\.env(\..+)?$/, /\.pem$/, /\.key$/, /\.pfx$/, /\.p12$/];
 const isSecretFile = (fileName: string): boolean => SKIP_FILE_PATTERNS.some((pattern) => pattern.test(fileName));
 
-export const collectSourceFiles = async (actorName: string, actorDir: string): Promise<ActorVersionSourceFile[]> => {
+export const collectSourceFiles = async (actorName: string, actorDir: string): Promise<SourceFile[]> => {
     const repoRoot = process.cwd();
     const absActorDir = path.resolve(actorDir);
 
@@ -34,9 +37,7 @@ export const collectSourceFiles = async (actorName: string, actorDir: string): P
     const keptFilePaths = collectNonIgnoredFiles(dockerContextDirAbs, repoRoot);
 
     if (!isMonorepoActor) {
-        return Promise.all(
-            keptFilePaths.map(async (filePath) => toActorVersionSourceFile(filePath, dockerContextDirAbs)),
-        );
+        return Promise.all(keptFilePaths.map(async (filePath) => readSourceFile(filePath, dockerContextDirAbs)));
     }
 
     const { tempDir, filePaths } = await flattenMonorepoContext(
@@ -47,7 +48,7 @@ export const collectSourceFiles = async (actorName: string, actorDir: string): P
         keptFilePaths,
     );
     try {
-        return await Promise.all(filePaths.map(async (filePath) => toActorVersionSourceFile(filePath, tempDir)));
+        return await Promise.all(filePaths.map(async (filePath) => readSourceFile(filePath, tempDir)));
     } finally {
         // Only the flattened copy is temporary — never delete the actor's own directory.
         await fs.rm(tempDir, { recursive: true, force: true });
@@ -197,26 +198,20 @@ export const runBuildsFromLocal = async ({
         for (const { actorFullName, folder } of actorConfigs) {
             console.error(`  ${actorFullName} (${folder})`);
         }
-        return actorConfigs.map(({ actorFullName }) => ({
-            buildId: 'dry-run',
-            actorRawId: 'dry-run',
-            buildNumber: '0.98.0',
-            actorFullName,
-        }));
+        return actorConfigs.map(({ actorFullName }) => dryRunBuildData(actorFullName, LOCAL_SOURCE_VERSION_NUMBER));
     }
 
-    console.error('=========================================');
-    console.error('STARTED LOCAL BUILDS:');
-    const buildersByActorFullName = new Map<string, ApifyBuilder>(
-        actorConfigs.map((actorConfig) => [actorConfig.actorFullName, ApifyBuilder.fromActorConfig(actorConfig)]),
-    );
-    const startedBuilds = await Promise.all(
-        actorConfigs.map(async ({ actorFullName, folder }) => {
-            const builder = buildersByActorFullName.get(actorFullName)!;
-            const sourceFiles = await collectSourceFiles(actorFullName, folder);
-            return builder.startActorBuildFromSourceFiles(sourceFiles);
-        }),
-    );
-
-    return waitAndSummarizeBuilds(startedBuilds, buildersByActorFullName, 'LOCAL BUILDS');
+    return runAndSummarizeBuilds(actorConfigs, 'LOCAL BUILDS', async (actorConfig, builder) => {
+        // Zipped and uploaded like `apify push` does, since inline SOURCE_FILES are capped at ~9 MB.
+        const zip = new AdmZip();
+        for (const { name, content } of await collectSourceFiles(actorConfig.actorFullName, actorConfig.folder)) {
+            zip.addFile(name, content);
+        }
+        const actorVersion: ActorVersion = {
+            versionNumber: LOCAL_SOURCE_VERSION_NUMBER,
+            tarballUrl: await builder.uploadSourceZip(LOCAL_SOURCE_VERSION_NUMBER, zip.toBuffer()),
+            sourceType: ActorSourceType.Tarball,
+        };
+        return builder.createVersionAndBuild(LOCAL_SOURCE_VERSION_NUMBER, actorVersion, false);
+    });
 };

package/bin/build.ts

@@ -1,7 +1,5 @@
-import type { ActorVersionSourceFile, Build } from 'apify-client';
-import { ApifyClient } from 'apify-client';
-
-import { ACTOR_SOURCE_TYPES } from '@apify/consts';
+import type { ActorVersion, Build } from 'apify-client';
+import { ActorSourceType, ApifyClient } from 'apify-client';
 
 import type { ActorConfig, BuildData } from './types.js';
 
@@ -12,6 +10,11 @@ type BuildPrActorOptions = {
     actorConfig: ActorConfig;
     useDockerCache: boolean;
 };
+
+// Fixed version number used to build from local source files, since there is no real version to track.
+export const LOCAL_SOURCE_VERSION_NUMBER = '0.98';
+const DEFAULT_TEST_VERSION_NUMBER = '0.99';
+
 export class ApifyBuilder {
     private constructor(
         private readonly apifyClient: ApifyClient,
@@ -57,12 +60,27 @@ export class ApifyBuilder {
         return { defaultBuildNumber, defaultVersionNumber, defaultBuildTag };
     };
 
-    startActorBuild = async ({
-        buildTag,
-        versionNumber,
-        gitRepoUrl,
-        useDockerCache,
-    }: BuildPrActorOptions): Promise<BuildData> => {
+    // Mirrors `apify push`: stores the zip in the Actor's `actor-<id>-source` KV store and returns a signed
+    // record URL the builder can download without a token.
+    uploadSourceZip = async (versionNumber: string, zip: Buffer): Promise<string> => {
+        const actorInfo = await this.apifyClient.actor(this.actorFullName).get();
+        if (!actorInfo) throw new Error(`No actor named '${this.actorFullName}' was found on the platform.`);
+
+        const store = await this.apifyClient.keyValueStores().getOrCreate(`actor-${actorInfo.id}-source`);
+        const storeClient = this.apifyClient.keyValueStore(store.id);
+        const key = `version-${versionNumber}.zip`;
+        await storeClient.setRecord({ key, value: zip as never, contentType: 'application/zip' });
+
+        const url = new URL(await storeClient.getRecordPublicUrl(key));
+        url.searchParams.set('disableRedirect', 'true');
+        return url.toString();
+    };
+
+    createVersionAndBuild = async (
+        versionNumber: string,
+        actorVersion: ActorVersion,
+        useCache: boolean,
+    ): Promise<BuildData> => {
         const actorClient = this.apifyClient.actor(this.actorFullName);
         const actorInfo = await actorClient.get();
         if (!actorInfo) {
@@ -73,17 +91,6 @@ export class ApifyBuilder {
             );
         }
 
-        // NOTE: I couldn't find this type, so I had to extract it :(
-        type ActorVersion = Parameters<ReturnType<typeof actorClient.version>['update']>[0];
-        const actorVersion: ActorVersion = {
-            buildTag,
-            versionNumber,
-            gitRepoUrl,
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore: coudn't find this type either :(
-            sourceType: ACTOR_SOURCE_TYPES.GIT_REPO,
-        };
-
         // Prepare version
         const versionExists = !actorInfo.versions.find((version) => version.versionNumber === versionNumber);
         if (versionExists) {
@@ -95,45 +102,12 @@ export class ApifyBuilder {
         }
 
         // We also get back actId so the testing actor can both match by actor ID and name
-        const { id, actId, buildNumber } = await actorClient.build(versionNumber, { useCache: useDockerCache });
+        const { id, actId, buildNumber } = await actorClient.build(versionNumber, { useCache });
 
         console.error(`[${this.actorFullName}]: ${id} (${buildNumber})`);
         return { buildId: id, actorRawId: actId, buildNumber, actorFullName: this.actorFullName };
     };
 
-    startActorBuildFromSourceFiles = async (sourceFiles: ActorVersionSourceFile[]): Promise<BuildData> => {
-        const ZIP_VERSION = '0.98';
-        const actorClient = this.apifyClient.actor(this.actorFullName);
-        const actorInfo = await actorClient.get();
-        if (!actorInfo) {
-            throw new Error(
-                `No actor named '${this.actorFullName}' was found on the platform. If this` +
-                    ' is unexpected, make sure the actor you are targeting is spelled the' +
-                    ' same as the folder in the repository.',
-            );
-        }
-
-        type ActorVersion = Parameters<ReturnType<typeof actorClient.version>['update']>[0];
-        const actorVersion: ActorVersion = {
-            versionNumber: ZIP_VERSION,
-            sourceFiles,
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore: couldn't find this type :(
-            sourceType: ACTOR_SOURCE_TYPES.SOURCE_FILES,
-        };
-
-        const versionExists = !actorInfo.versions.find((v) => v.versionNumber === ZIP_VERSION);
-        if (versionExists) {
-            await actorClient.versions().create(actorVersion);
-        } else {
-            await actorClient.version(ZIP_VERSION).update(actorVersion);
-        }
-
-        const { id, actId, buildNumber } = await actorClient.build(ZIP_VERSION, { useCache: false });
-        console.error(`[${this.actorFullName}]: ${id} (${buildNumber})`);
-        return { buildId: id, actorRawId: actId, buildNumber, actorFullName: this.actorFullName };
-    };
-
     waitForBuildToFinish = async (buildId: string): Promise<Build> => {
         const build = await this.apifyClient.build(buildId).waitForFinish();
         const versionNumber = build.buildNumber;
@@ -281,6 +255,33 @@ export const waitAndSummarizeBuilds = async (
     return startedBuilds;
 };
 
+export const runAndSummarizeBuilds = async (
+    actorConfigs: ActorConfig[],
+    label: string,
+    buildOneActor: (actorConfig: ActorConfig, builder: ApifyBuilder) => Promise<BuildData>,
+): Promise<BuildData[]> => {
+    const buildersByActorFullName = new Map<string, ApifyBuilder>(
+        actorConfigs.map((actorConfig) => [actorConfig.actorFullName, ApifyBuilder.fromActorConfig(actorConfig)]),
+    );
+    console.error('=========================================');
+    console.error(`STARTED ${label}:`);
+    const startedBuilds = await Promise.all(
+        actorConfigs.map(async (actorConfig) =>
+            buildOneActor(actorConfig, buildersByActorFullName.get(actorConfig.actorFullName)!),
+        ),
+    );
+
+    return waitAndSummarizeBuilds(startedBuilds, buildersByActorFullName, label);
+};
+
+// Placeholder BuildData for dry runs, since no real build was triggered.
+export const dryRunBuildData = (actorFullName: string, versionNumber: string): BuildData => ({
+    buildId: 'dry-run',
+    actorRawId: 'dry-run',
+    buildNumber: versionNumber,
+    actorFullName,
+});
+
 type RunBuildsOptions = {
     actorConfigs: ActorConfig[];
     isLatest?: boolean;
@@ -297,7 +298,7 @@ export const runBuilds = async ({
     isLatest = false,
     dryRun,
     useDockerCache,
-}: RunBuildsOptions) => {
+}: RunBuildsOptions): Promise<BuildData[]> => {
     const buildConfigs: BuildPrActorOptions[] = [];
 
     for (const actorConfig of actorConfigs) {
@@ -310,7 +311,7 @@ export const runBuilds = async ({
             versionNumber = defaultVersionNumber;
             buildTag = defaultBuildTag;
         } else {
-            versionNumber = '0.99';
+            versionNumber = DEFAULT_TEST_VERSION_NUMBER;
         }
 
         // Depending on if these are miniactors or standaloneActors
@@ -322,23 +323,34 @@ export const runBuilds = async ({
     }
 
     if (dryRun) {
-        return buildConfigs;
+        console.error('[DRY RUN] Would build:');
+        for (const { actorConfig, versionNumber } of buildConfigs) {
+            console.error(`  ${actorConfig.actorFullName} (${versionNumber})`);
+        }
+        return buildConfigs.map(({ actorConfig, versionNumber }) =>
+            dryRunBuildData(actorConfig.actorFullName, versionNumber),
+        );
     }
 
-    const buildersByActorFullName = new Map<string, ApifyBuilder>(
-        actorConfigs.map((actorConfig) => [actorConfig.actorFullName, ApifyBuilder.fromActorConfig(actorConfig)]),
-    );
-    console.error('=========================================');
-    console.error('STARTED BUILDS:');
-    const startedBuilds = await Promise.all(
-        buildConfigs.map(async (buildConfig) => {
-            const builder = buildersByActorFullName.get(buildConfig.actorConfig.actorFullName)!;
-            const buildData = await builder.startActorBuild(buildConfig);
-            return buildData;
-        }),
+    const buildConfigsByActorFullName = new Map(
+        buildConfigs.map((buildConfig) => [buildConfig.actorConfig.actorFullName, buildConfig]),
     );
 
-    return waitAndSummarizeBuilds(startedBuilds, buildersByActorFullName, 'BUILDS');
+    return runAndSummarizeBuilds(actorConfigs, 'BUILDS', async (actorConfig, builder) => {
+        const {
+            buildTag,
+            versionNumber,
+            gitRepoUrl,
+            useDockerCache: useCache,
+        } = buildConfigsByActorFullName.get(actorConfig.actorFullName)!;
+        const actorVersion: ActorVersion = {
+            buildTag,
+            versionNumber,
+            gitRepoUrl,
+            sourceType: ActorSourceType.GitRepo,
+        };
+        return builder.createVersionAndBuild(versionNumber, actorVersion, useCache);
+    });
 };
 
 export const deleteOldBuilds = async (actorConfigs: ActorConfig[]) => {

package/bin/main.ts

@@ -14,7 +14,8 @@ import { getPushData } from './github.js';
 import { notifyToSlack } from './slack.js';
 import { reportTestResults } from './test-report.js';
 import type { Config } from './types.js';
-import { readConfigFile, setCwd, spawnCommandInGhWorkspace } from './utils.js';
+import { setCwd, spawnCommandInGhWorkspace } from './utils.js';
+import { readConfigFile } from './utils/config/load-config.js';
 
 /**
  * Middlewares to be run before every command execution

package/bin/types.ts

@@ -87,17 +87,6 @@ export interface GithubCommit {
     modified: string[];
 }
 
-export interface ActorConfigFileEntry {
-    folder: string;
-    actorFullName: string;
-    tokenEnvVar: string;
-    overrideActorContext?: string[];
-}
-
-export interface ActorConfigFile {
-    actors: ActorConfigFileEntry[];
-}
-
 export interface BuildData {
     buildId: string;
     actorRawId: string;