apify-test-tools 0.9.1-beta.9 → 0.10.0

package/bin/main.ts

@@ -2,19 +2,28 @@
 
 import process from 'node:process';
 
-import yargs, { type Argv } from 'yargs';
+import yargs, { type Options } from 'yargs';
 // eslint-disable-next-line import/extensions --- With .js, it cannot find types
 import { hideBin } from 'yargs/helpers';
 
 import { deleteOldBuilds, runBuilds } from './build.js';
 import { runBuildsFromLocal } from './build-from-local.js';
 import { getChangedActors } from './diff-changes.js';
-import { getBranchOnlyChangedFiles, getChangedFiles, getCommits, hasMergeFromTarget } from './git.js';
-import { getPushData } from './github.js';
+import {
+    getBranchOnlyChangedFiles,
+    getChangedFiles,
+    getCommits,
+    getCurrentBranch,
+    getReleaseChanges,
+    getRepoName,
+    hasMergeFromTarget,
+    resolveReleaseBaseCommit,
+    resolveRepoUrl,
+} from './git.js';
 import { notifyToSlack } from './slack.js';
 import { reportTestResults } from './test-report.js';
 import type { Config } from './types.js';
-import { setCwd, spawnCommandInGhWorkspace } from './utils.js';
+import { setCwd } from './utils.js';
 import { readConfigFile } from './utils/config/load-config.js';
 
 /**
@@ -22,44 +31,48 @@ import { readConfigFile } from './utils/config/load-config.js';
  */
 const middlewares = [setCwd];
 
-export const buildOptions = <T>(y: Argv<T>) => {
-    return y
-        .option('target-branch', {
-            type: 'string',
-            demandOption: true,
-        })
-        .option('source-branch', {
-            type: 'string',
-            demandOption: true,
-        })
-        .option('use-docker-cache', {
-            type: 'boolean',
-            default: false,
-        })
-        .option('base-commit', {
-            type: 'string',
-            demandOption: false,
-        });
-};
+/*
+ * 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)`)
+ * instead of nesting wrapper functions. `as const` keeps literals like `demandOption: true` so yargs
+ * can infer non-optional types; `satisfies` validates the shape without widening it.
+ */
+
+/** Commit range to inspect: everything on `source-branch` since it diverged from `target-branch`. */
+const gitRangeOptions = {
+    'target-branch': { type: 'string', demandOption: true },
+    'source-branch': { type: 'string', demandOption: true },
+    'base-commit': { type: 'string', demandOption: false },
+} as const satisfies Record<string, Options>;
+
+/**
+ * Where to build the Actors from. Defaults to the `origin` remote, which is then checked against each
+ * Actor's default version. Passing it explicitly skips that check (see assertRepoUrlMatchesDefaultVersion).
+ */
+const repoUrlOptions = {
+    'repo-url': { type: 'string' },
+} as const satisfies Record<string, Options>;
 
 /**
  * Actor-selection flags, applied to every command that reads the actor config so a caller can
  * narrow the set it operates on (e.g. two-stage releases: `--ignore X`, then `--actors X`).
- * Kept separate from `buildOptions` so the read-only git commands don't advertise flags they ignore.
+ * Kept separate from `gitRangeOptions` so the read-only git commands don't advertise flags they ignore.
  */
-export const actorSelectionOptions = <T>(y: Argv<T>) => {
-    return y
-        .option('actors', {
-            type: 'string',
-            array: true,
-            default: [] as string[],
-        })
-        .option('ignore', {
-            type: 'string',
-            array: true,
-            default: [] as string[],
-        });
-};
+const actorSelectionOptions = {
+    actors: { type: 'string', array: true, default: [] as string[] },
+    ignore: { type: 'string', array: true, default: [] as string[] },
+} as const satisfies Record<string, Options>;
+
+/** Flags for commands that trigger Apify builds. */
+const buildOptions = {
+    'use-docker-cache': { type: 'boolean', default: false },
+} as const satisfies Record<string, Options>;
+
+/** Global flags, available to every command. */
+const globalOptions = {
+    'dry-run': { type: 'boolean', default: false },
+    workspace: { type: 'string' },
+} as const satisfies Record<string, Options>;
 
 const resolveChangedActors = async (config: Config, { isLatest }: { isLatest: boolean }) => {
     const actorConfigs = await readConfigFile(config);
@@ -98,37 +111,51 @@ const resolveChangedActors = async (config: Config, { isLatest }: { isLatest: bo
 
 await yargs()
     .scriptName('public-actors-utils')
-    .option('dry-run', {
-        type: 'boolean',
-        default: false,
-    })
-    .option('workspace', {
-        type: 'string',
-    })
+    .options(globalOptions)
     .middleware(middlewares)
-    .command('get-commits', '', buildOptions, (args) => {
-        const commits = getCommits(args);
-        console.log(JSON.stringify(commits));
-    })
-    .command('get-latest-commit', '', buildOptions, (args) => {
-        const commits = getCommits(args);
-        if (commits.length > 0) {
-            console.log(JSON.stringify(commits[commits.length - 1]));
-        }
-    })
-    .command('get-changed-files', '', buildOptions, (args) => {
-        const commits = getCommits(args);
-        const changedFiles = getChangedFiles(commits);
-        console.log(JSON.stringify(changedFiles));
-    })
-    .command('get-actor-configs', '', actorSelectionOptions, async ({ actors, ignore }) => {
-        const actorConfigs = await readConfigFile({ actors, ignore });
-        console.log(JSON.stringify(actorConfigs));
-    })
+    .command(
+        'get-commits',
+        '',
+        (y) => y.options(gitRangeOptions),
+        (args) => {
+            const commits = getCommits(args);
+            console.log(JSON.stringify(commits));
+        },
+    )
+    .command(
+        'get-latest-commit',
+        '',
+        (y) => y.options(gitRangeOptions),
+        (args) => {
+            const commits = getCommits(args);
+            if (commits.length > 0) {
+                console.log(JSON.stringify(commits[commits.length - 1]));
+            }
+        },
+    )
+    .command(
+        'get-changed-files',
+        '',
+        (y) => y.options(gitRangeOptions),
+        (args) => {
+            const commits = getCommits(args);
+            const changedFiles = getChangedFiles(commits);
+            console.log(JSON.stringify(changedFiles));
+        },
+    )
+    .command(
+        'get-actor-configs',
+        '',
+        (y) => y.options(actorSelectionOptions),
+        async ({ actors, ignore }) => {
+            const actorConfigs = await readConfigFile({ actors, ignore });
+            console.log(JSON.stringify(actorConfigs));
+        },
+    )
     .command(
         'get-affected-actors',
         '',
-        (args) => actorSelectionOptions(buildOptions(args)),
+        (y) => y.options(gitRangeOptions).options(actorSelectionOptions),
         async (config) => {
             const actorsChanged = await resolveChangedActors(config, { isLatest: false });
             console.log(JSON.stringify(actorsChanged));
@@ -137,8 +164,8 @@ await yargs()
     .command(
         'report-tests',
         '',
-        (args) =>
-            args
+        (y) =>
+            y
                 .option('report-file', { type: 'string', demandOption: true })
                 .option('report-slack-channel', { type: 'string' })
                 .option('job-url', { type: 'string' })
@@ -150,18 +177,11 @@ await yargs()
     .command(
         'build',
         '',
-        (args) => actorSelectionOptions(buildOptions(args)).option('dry-run', { type: 'boolean', default: false }),
+        (y) => y.options(gitRangeOptions).options(actorSelectionOptions).options(buildOptions).options(repoUrlOptions),
         async (config) => {
             const actorsChanged = await resolveChangedActors(config, { isLatest: false });
-            // https://github.com/apify-store/google-maps#:actors/lukaskrivka_google-maps-with-contact-details
-            // git@github.com:apify-store/google-maps#:actors/lukaskrivka_google-maps-with-contact-details
-            const repoUrl = spawnCommandInGhWorkspace(`git remote get-url origin`).replace(
-                /^https:\/\/github\.com\//,
-                'git@github.com:',
-            );
-
             const builds = await runBuilds({
-                repoUrl,
+                ...resolveRepoUrl(config.repoUrl),
                 actorConfigs: actorsChanged,
                 branch: config.sourceBranch.replace('origin/', ''),
                 dryRun: config.dryRun,
@@ -173,17 +193,27 @@ await yargs()
     .command(
         'release',
         '',
-        (args) =>
-            actorSelectionOptions(args)
-                .option('push-event-path', { type: 'string', demandOption: true })
-                .option('dry-run', { type: 'boolean', default: false })
+        (y) =>
+            y
+                .options(actorSelectionOptions)
+                .options(buildOptions)
+                .options(repoUrlOptions)
+                // The last commit that is already released, everything after it up to HEAD gets released.
+                // Required, see the README section "Releasing Actors" for how to set it for each merge strategy.
+                .option('base-commit', { type: 'string', demandOption: true })
                 .option('report-slack-channel', { type: 'string' })
-                .option('release-slack-channel', { type: 'string' })
-                .option('use-docker-cache', { type: 'boolean', default: false }),
+                .option('release-slack-channel', { type: 'string' }),
         async (args) => {
-            const { branch, changedFiles, repoUrl, commits, changelog, repository, author } = await getPushData(
-                args.pushEventPath,
-            );
+            const baseSha = resolveReleaseBaseCommit(args.baseCommit);
+            const branch = getCurrentBranch();
+            const changes = getReleaseChanges(baseSha);
+            if (!changes) {
+                console.error(`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 isLatest = true;
             const actorConfigs = await readConfigFile(args);
             const actorsChanged = getChangedActors({
@@ -196,6 +226,7 @@ await yargs()
             const builds = await runBuilds({
                 isLatest,
                 repoUrl,
+                shouldVerifyRepoUrl,
                 actorConfigs: actorsChanged,
                 branch,
                 dryRun,
@@ -207,9 +238,10 @@ await yargs()
                 changedFiles,
                 commits,
                 changelog,
-                repository,
+                repository: getRepoName(repoUrl),
                 dryRun,
-                author,
+                // The newest commit, same as the pushed head commit
+                author: commits[commits.length - 1].author,
                 reportSlackChannel,
                 releaseSlackChannel,
             });
@@ -218,17 +250,22 @@ await yargs()
     .command(
         'build-from-local',
         '',
-        (args) => actorSelectionOptions(args).option('dry-run', { type: 'boolean', default: false }),
+        (y) => y.options(actorSelectionOptions),
         async ({ actors, ignore, dryRun }) => {
             const actorConfigs = await readConfigFile({ actors, ignore });
             const builds = await runBuildsFromLocal({ actorConfigs, dryRun });
             console.log(JSON.stringify(builds));
         },
     )
-    .command('delete-old-builds', '', actorSelectionOptions, async ({ actors, ignore }) => {
-        const actorConfigs = await readConfigFile({ actors, ignore });
-        await deleteOldBuilds(actorConfigs);
-    })
+    .command(
+        'delete-old-builds',
+        '',
+        (y) => y.options(actorSelectionOptions),
+        async ({ actors, ignore }) => {
+            const actorConfigs = await readConfigFile({ actors, ignore });
+            await deleteOldBuilds(actorConfigs);
+        },
+    )
     .strictCommands()
     .demandCommand(1, 'Command is required')
     .fail((msg, err, yargsInstance) => {

package/bin/slack.ts

@@ -14,6 +14,9 @@ type NotifyToSlackOptions = {
     reportSlackChannel?: string;
 };
 
+// Git authors come as "Name<email>", Slack only needs the name
+const displayName = (author: string) => author.replace(/\s*<[^>]*>$/, '');
+
 export const notifyToSlack = async ({
     changedFiles,
     commits,
@@ -30,7 +33,7 @@ export const notifyToSlack = async ({
         console.warn('No new changelog entries found, did you forget to update it?');
     }
 
-    let shortMessage = `*${repository}* – New release (by ${author}):\n\n`;
+    let shortMessage = `*${repository}* – New release (by ${displayName(author)}):\n\n`;
 
     // This one is just for broader public that only cares about public facing changes
     if (changelog && releaseSlackChannel) {
@@ -49,7 +52,7 @@ export const notifyToSlack = async ({
     const commitsMessage = `${commits
         .map(
             ({ author: commitAuthor, message }, index) =>
-                `${index + 1}. Commit message: ${message}\n\tAuthor: ${commitAuthor}.`,
+                `${index + 1}. Commit message: ${message}\n\tAuthor: ${displayName(commitAuthor)}.`,
         )
         .join('\n')}`;
     const changedFilesMessage = `*Files changed*: ${changedFiles.map((file) => `\`${file}\``).join(', ')}`;

package/bin/types.ts

@@ -14,79 +14,6 @@ export type Commit = {
     message: string;
 };
 
-// NOTE: The GitHub types are incomplete, feel free to add fields/complete (not sure how stable GitHub API is)
-export interface GitHubHeadCommit {
-    added: string[];
-    removed: string[];
-    modified: string[];
-    author: {
-        name: string;
-    };
-    message: string;
-    id: string;
-}
-
-export interface Repository {
-    full_name: string;
-    name: string;
-    ssh_url: string;
-    owner: {
-        login: string;
-    };
-}
-
-export type GitHubEvent = GitHubEventPullRequest | GitHubEventPush;
-
-export interface GitHubEventPullRequest {
-    // Type is our own variable we inject to have discriminated union
-    // The rest of the properties are raw from GitHub API
-    type: 'pull_request';
-    pull_request: {
-        number: number;
-        base: {
-            ref: string;
-            sha: string;
-        };
-        head: {
-            ref: string;
-            sha: string;
-        };
-    };
-    repository: Repository;
-}
-
-export interface GitHubEventPush {
-    type: 'push';
-    head_commit: GitHubHeadCommit;
-    repository: Repository;
-    ref: string;
-    commits: GithubCommit[];
-    before: string;
-    after: string;
-}
-
-export interface GithubCommit {
-    id: string;
-    tree_id: string;
-    distinct: boolean;
-    message: string;
-    timestamp: string;
-    url: string;
-    author: {
-        name: string;
-        email: string;
-        username: string;
-    };
-    committer: {
-        name: string;
-        email: string;
-        username: string;
-    };
-    added: string[];
-    removed: string[];
-    modified: string[];
-}
-
 export interface BuildData {
     buildId: string;
     actorRawId: string;

package/bin/utils/config/parser.ts

@@ -1,6 +1,7 @@
 import z from 'zod';
 
 import { CONFIG_FILE_STRATEGY, type ResolvedActorConfig, type StrategyParser } from './structures/base.js';
+import { GROUPED_PARSER } from './structures/grouped.js';
 import { LEGACY_PARSER } from './structures/legacy.js';
 
 const CONFIG_FILE_STRATEGIES: {
@@ -8,9 +9,10 @@ const CONFIG_FILE_STRATEGIES: {
     [key in CONFIG_FILE_STRATEGY]: StrategyParser & { mode: key };
 } = {
     [CONFIG_FILE_STRATEGY.LEGACY]: LEGACY_PARSER,
+    [CONFIG_FILE_STRATEGY.GROUPED]: GROUPED_PARSER,
 } as const;
 
-const ModeSelectionSchema = z.enum(CONFIG_FILE_STRATEGY).default(CONFIG_FILE_STRATEGY.LEGACY);
+const ModeSelectionSchema = z.object({ mode: z.enum(CONFIG_FILE_STRATEGY).default(CONFIG_FILE_STRATEGY.LEGACY) });
 
 function selectStrategy(mode: unknown): StrategyParser {
     const parsed = ModeSelectionSchema.safeParse(mode);
@@ -18,7 +20,7 @@ function selectStrategy(mode: unknown): StrategyParser {
         throw new Error(z.prettifyError(parsed.error));
     }
 
-    return CONFIG_FILE_STRATEGIES[parsed.data];
+    return CONFIG_FILE_STRATEGIES[parsed.data.mode];
 }
 
 // Strips a trailing slash so config-declared paths ("actors/shopify/" vs "actors/shopify") compare equal.
@@ -79,10 +81,9 @@ export const _privates = {
 };
 
 export function parseConfigFile(body: Record<string, unknown>): ResolvedActorConfig[] {
-    const { mode, ...rest } = body;
-    const strategy = selectStrategy(mode);
+    const strategy = selectStrategy(body);
 
-    const resolved = strategy.parse(rest);
+    const resolved = strategy.parse(body);
     const validated = verifyConfiguration(resolved);
     return validated;
 }

package/bin/utils/config/structures/base.ts

@@ -11,15 +11,19 @@ export const ACTOR_FULL_NAME_REGEX = new RegExp(
     USERNAME.REGEX.flags + ACTOR_NAME.REGEX.flags,
 );
 
+// All fields must exist, even if their value can be undefined.
+// This makes typescript enforce all configs to have resolution for EVERY field.
+// So adding an extra field here creates TS errors in every config file that doesn't have it.
 export interface ResolvedActorConfig {
     actorFullName: string;
     folder: string;
     tokenEnvVar: string;
-    overrideActorContext?: string[];
+    overrideActorContext: string[] | undefined;
 }
 
 export enum CONFIG_FILE_STRATEGY {
     LEGACY = 'legacy',
+    GROUPED = 'grouped',
 }
 
 export type StrategyParser = {

package/bin/utils/config/structures/grouped.ts

@@ -0,0 +1,40 @@
+import z from 'zod';
+
+import { ACTOR_FULL_NAME_REGEX, CONFIG_FILE_STRATEGY, defineStrategy } from './base.js';
+
+const schema = z.object({
+    groups: z
+        .record(
+            z.string(),
+            z.object({
+                actors: z
+                    .array(
+                        z.object({
+                            folder: z.string(),
+                            actorFullName: z.string().regex(ACTOR_FULL_NAME_REGEX),
+                            // these allow overrides from stuff set at the group level
+                            tokenEnvVar: z.string().optional(),
+                            overrideActorContext: z.array(z.string()).optional(),
+                        }),
+                    )
+                    .min(1),
+                tokenEnvVar: z.string(),
+                overrideActorContext: z.array(z.string()).optional(),
+            }),
+        )
+        .refine((data) => Object.keys(data).length > 0, 'Invalid input: At least one configuration group is required.'),
+});
+
+type GroupedConfig = z.infer<typeof schema>;
+
+export const GROUPED_PARSER = defineStrategy(CONFIG_FILE_STRATEGY.GROUPED, schema, (body: GroupedConfig) => {
+    const entries = Object.entries(body.groups);
+    return entries.flatMap(([_folder, entry]) =>
+        entry.actors.map((actor) => ({
+            tokenEnvVar: entry.tokenEnvVar,
+            overrideActorContext: entry.overrideActorContext,
+            // last so actor can override stuff from the group
+            ...actor,
+        })),
+    );
+});

package/bin/utils/config/structures/legacy.ts

@@ -17,4 +17,6 @@ const schema = z.object({
 
 type LegacyConfig = z.infer<typeof schema>;
 
-export const LEGACY_PARSER = defineStrategy(CONFIG_FILE_STRATEGY.LEGACY, schema, (body: LegacyConfig) => body.actors);
+export const LEGACY_PARSER = defineStrategy(CONFIG_FILE_STRATEGY.LEGACY, schema, (body: LegacyConfig) =>
+    body.actors.map((x) => ({ overrideActorContext: undefined, ...x })),
+);

package/bin/utils.ts

@@ -2,10 +2,6 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import type { ActorVersionSourceFile } from 'apify-client';
-
-import { SOURCE_FILE_FORMATS } from '@apify/consts';
-
 // Returns true when `childPath` is not inside `parentPath`.
 // Used to detect monorepo actors whose dockerContextDir escapes the actor directory.
 export const isOutsideDir = (childPath: string, parentPath: string): boolean =>
@@ -55,15 +51,12 @@ export const getGitignoredPaths = (relativePaths: string[]): Set<string> => {
     return new Set(result.stdout.toString().split('\n').filter(Boolean));
 };
 
-const isBinary = (buffer: Buffer): boolean => buffer.includes(0);
+export type SourceFile = { name: string; content: Buffer };
 
-export const toActorVersionSourceFile = async (absPath: string, rootDir: string): Promise<ActorVersionSourceFile> => {
-    const buffer = await fs.readFile(absPath);
-    const name = path.relative(rootDir, absPath).split(path.sep).join('/');
-    return isBinary(buffer)
-        ? { name, format: SOURCE_FILE_FORMATS.BASE64, content: buffer.toString('base64') }
-        : { name, format: SOURCE_FILE_FORMATS.TEXT, content: buffer.toString('utf8') };
-};
+export const readSourceFile = async (absPath: string, rootDir: string): Promise<SourceFile> => ({
+    name: path.relative(rootDir, absPath).split(path.sep).join('/'),
+    content: await fs.readFile(absPath),
+});
 
 export const spawnCommandInGhWorkspace = (command: string, args: string[] = []) => {
     console.error(command, args.join(' '));
@@ -91,11 +84,10 @@ export const getEnvVar = (varName: string, defaultValue?: string): string => {
     return value;
 };
 
+// Commands expect to run from the repository root (config file and Actor folders are relative to it).
+// That is the current directory by default, --workspace points elsewhere, e.g. for local development.
 export const setCwd = ({ workspace }: { workspace: string | undefined }) => {
     if (workspace) {
         process.chdir(workspace);
-        return;
     }
-    const ghWorkspace = getEnvVar('GITHUB_WORKSPACE', process.cwd());
-    process.chdir(ghWorkspace);
 };

package/dist/bin/build-from-local.d.ts

@@ -1,6 +1,6 @@
-import type { ActorVersionSourceFile } from 'apify-client';
 import type { ActorConfig, BuildData } from './types.js';
-export declare const collectSourceFiles: (actorName: string, actorDir: string) => Promise<ActorVersionSourceFile[]>;
+import type { SourceFile } from './utils.js';
+export declare const collectSourceFiles: (actorName: string, actorDir: string) => Promise<SourceFile[]>;
 export declare const collectNonIgnoredFiles: (dockerContextDir: string, repoRoot: string) => string[];
 export declare const flattenMonorepoContext: (actorName: string, absActorDir: string, contextAbsDir: string, actorJson: Record<string, unknown>, keptContextFiles: string[]) => Promise<{
     tempDir: string;

package/dist/bin/build-from-local.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-from-local.d.ts","sourceRoot":"","sources":["../../bin/build-from-local.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAgB,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAMzE,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAUzD,eAAO,MAAM,kBAAkB,GAAU,WAAW,MAAM,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,sBAAsB,EAAE,CAmC9G,CAAC;AAWF,eAAO,MAAM,sBAAsB,GAAI,kBAAkB,MAAM,EAAE,UAAU,MAAM,KAAG,MAAM,EAoBzF,CAAC;AAaF,eAAO,MAAM,sBAAsB,GAC/B,WAAW,MAAM,EACjB,aAAa,MAAM,EACnB,eAAe,MAAM,EACrB,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,kBAAkB,MAAM,EAAE,KAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAyClD,CAAC;AAcF,eAAO,MAAM,qBAAqB,GAC9B,aAAa,MAAM,EACnB,eAAe,MAAM,EACrB,SAAS,MAAM,EACf,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACnC,OAAO,CAAC,IAAI,CAqBd,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,2BAGtC;IACC,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,MAAM,EAAE,OAAO,CAAC;CACnB,KAAG,OAAO,CAAC,SAAS,EAAE,CAkBtB,CAAC"}
+{"version":3,"file":"build-from-local.d.ts","sourceRoot":"","sources":["../../bin/build-from-local.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAU7C,eAAO,MAAM,kBAAkB,GAAU,WAAW,MAAM,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,UAAU,EAAE,CAiClG,CAAC;AAWF,eAAO,MAAM,sBAAsB,GAAI,kBAAkB,MAAM,EAAE,UAAU,MAAM,KAAG,MAAM,EAoBzF,CAAC;AAaF,eAAO,MAAM,sBAAsB,GAC/B,WAAW,MAAM,EACjB,aAAa,MAAM,EACnB,eAAe,MAAM,EACrB,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,kBAAkB,MAAM,EAAE,KAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAyClD,CAAC;AAcF,eAAO,MAAM,qBAAqB,GAC9B,aAAa,MAAM,EACnB,eAAe,MAAM,EACrB,SAAS,MAAM,EACf,WAAW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACnC,OAAO,CAAC,IAAI,CAqBd,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,2BAGtC;IACC,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,MAAM,EAAE,OAAO,CAAC;CACnB,KAAG,OAAO,CAAC,SAAS,EAAE,CAsBtB,CAAC"}

package/dist/bin/build-from-local.js

@@ -1,11 +1,12 @@
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import AdmZip from 'adm-zip';
 import { ActorSourceType } from 'apify-client';
 import { dryRunBuildData, LOCAL_SOURCE_VERSION_NUMBER, runAndSummarizeBuilds } from './build.js';
 import { buildDockerIgnoreMatcher } from './dockerignore.js';
 import { isPathWithinScope } from './path-utils.js';
-import { getGitignoredPaths, isOutsideDir, listRepoFilePaths, toActorVersionSourceFile } 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
 // excluded (build output, local overrides, project-specific secret files, ...) is expected to already be
@@ -26,11 +27,11 @@ export const collectSourceFiles = async (actorName, actorDir) => {
     const dockerContextDirAbs = isMonorepoActor ? contextAbsDir : absActorDir;
     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(actorName, absActorDir, contextAbsDir, actorJson, 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.
@@ -153,11 +154,15 @@ export const runBuildsFromLocal = async ({ actorConfigs, dryRun, }) => {
         return actorConfigs.map(({ actorFullName }) => dryRunBuildData(actorFullName, LOCAL_SOURCE_VERSION_NUMBER));
     }
     return runAndSummarizeBuilds(actorConfigs, 'LOCAL BUILDS', async (actorConfig, builder) => {
-        const sourceFiles = await collectSourceFiles(actorConfig.actorFullName, actorConfig.folder);
+        // 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 = {
             versionNumber: LOCAL_SOURCE_VERSION_NUMBER,
-            sourceFiles,
-            sourceType: ActorSourceType.SourceFiles,
+            tarballUrl: await builder.uploadSourceZip(LOCAL_SOURCE_VERSION_NUMBER, zip.toBuffer()),
+            sourceType: ActorSourceType.Tarball,
         };
         return builder.createVersionAndBuild(LOCAL_SOURCE_VERSION_NUMBER, actorVersion, false);
     });